@woosh/meep-engine 2.138.20 → 2.139.0

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

@@ -112,15 +112,31 @@ export function bt_mesh_face_decouple(
         const v1 = mesh.edge_read_vertex1(e);
         const v2 = mesh.edge_read_vertex2(e);
 
-        if (v_map.has(v1)) {
+        const v1_new = v_map.has(v1) ? v_map.get(v1) : v1;
+        const v2_new = v_map.has(v2) ? v_map.get(v2) : v2;
+
+        if (v1_new === v2_new && v1_new !== v1) {
+            // Both endpoints remap to the same vertex: this edge becomes a
+            // self-loop. Per the disk-cycle convention (see BinaryTopology.js
+            // __edge_pool comment) a self-loop occupies the v1 slot only.
+            // Detach from both old disks, update both vertex fields, then add
+            // once -- a second add would land on the v2 slot and corrupt v's
+            // disk cycle.
+            bt_disk_edge_remove(mesh, e, v1);
+            bt_disk_edge_remove(mesh, e, v2);
+            mesh.edge_write_vertex1(e, v1_new);
+            mesh.edge_write_vertex2(e, v2_new);
+            bt_disk_edge_add(mesh, e, v1_new);
+            continue;
+        }
+
+        if (v1_new !== v1) {
             bt_disk_edge_remove(mesh, e, v1);
-            const v1_new = v_map.get(v1);
             mesh.edge_write_vertex1(e, v1_new);
             bt_disk_edge_add(mesh, e, v1_new);
         }
-        if (v_map.has(v2)) {
+        if (v2_new !== v2) {
             bt_disk_edge_remove(mesh, e, v2);
-            const v2_new = v_map.get(v2);
             mesh.edge_write_vertex2(e, v2_new);
             bt_disk_edge_add(mesh, e, v2_new);
         }

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

@@ -1 +1 @@
-{"version":3,"file":"bt_mesh_simplify.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/core/geom/3d/topology/struct/binary/io/bt_mesh_simplify.js"],"names":[],"mappings":"AAqLA;;;;;;;;;;;;;;GAcG;AACH,0EAHW,MAAM,wBACN,IAAI,MAAM,CAAC,QA2HrB"}
+{"version":3,"file":"bt_mesh_simplify.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/core/geom/3d/topology/struct/binary/io/bt_mesh_simplify.js"],"names":[],"mappings":"AAqLA;;;;;;;;;;;;;;GAcG;AACH,0EAHW,MAAM,wBACN,IAAI,MAAM,CAAC,QA6HrB"}

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

@@ -295,9 +295,11 @@ export function bt_mesh_simplify(
         quadratics[pre_survivor].add(quadratics[pre_victim]);
         quadratics[pre_victim] = null;
 
-        // Kill any direct parallel edges between survivor and victim. Leaving them in
-        // place would cause bt_vertex_replace (inside bt_edge_collapse) to produce a
-        // self-loop edge (surv, surv), which corrupts the survivor's disk cycle.
+        // Kill any direct parallel edges between survivor and victim up front.
+        // bt_vertex_replace can safely move them into the survivor as self-loops
+        // (cf. the disk-cycle convention in BinaryTopology.js __edge_pool), but
+        // their faces are geometrically degenerate -- killing them here keeps
+        // current_face_count accurate without a post-collapse rescan.
         current_face_count -= bt_edge_kill_parallels(mesh, edge_id);
 
         const survivor = bt_edge_collapse(mesh, edge_id, scratch_target, 0);

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

@@ -1 +1 @@
-{"version":3,"file":"bt_edge_create.d.ts","sourceRoot":"","sources":["../../../../../../../../../../src/core/geom/3d/topology/struct/binary/io/edge/bt_edge_create.js"],"names":[],"mappings":"AA8DA;;;;;;GAMG;AACH,yDAJW,MAAM,MACN,MAAM,GACL,MAAM,CAsCjB"}
+{"version":3,"file":"bt_edge_create.d.ts","sourceRoot":"","sources":["../../../../../../../../../../src/core/geom/3d/topology/struct/binary/io/edge/bt_edge_create.js"],"names":[],"mappings":"AA8DA;;;;;;GAMG;AACH,yDAJW,MAAM,MACN,MAAM,GACL,MAAM,CA+CjB"}

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

@@ -89,6 +89,15 @@ export function bt_edge_create(mesh, v0, v1) {
         mesh.edge_write_v1_disk_prev(edge_id, edge_id);
     }
 
+    if (v0 === v1) {
+        // Self-loop: by convention the edge occupies the v1 slot of v's disk
+        // cycle only; the v2 slot is unused. Running the v1 link pass below
+        // would re-enter the same slot a second time, scribbling on its own
+        // disk_next pointer (typically setting it to self), and corrupting v's
+        // cycle. See BinaryTopology.js __edge_pool comment for the convention.
+        return edge_id;
+    }
+
     const first_v1_edge = mesh.vertex_read_edge(v1);
 
     if (first_v1_edge !== NULL_POINTER) {

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

@@ -1 +1 @@
-{"version":3,"file":"bt_edge_get_or_create.d.ts","sourceRoot":"","sources":["../../../../../../../../../../src/core/geom/3d/topology/struct/binary/io/edge/bt_edge_get_or_create.js"],"names":[],"mappings":"AAGA;;;;;;;GAOG;AACH,gEAJW,MAAM,MACN,MAAM,GACJ,MAAM,CAmClB"}
+{"version":3,"file":"bt_edge_get_or_create.d.ts","sourceRoot":"","sources":["../../../../../../../../../../src/core/geom/3d/topology/struct/binary/io/edge/bt_edge_get_or_create.js"],"names":[],"mappings":"AAIA;;;;;;;GAOG;AACH,gEAJW,MAAM,MACN,MAAM,GACJ,MAAM,CAUlB"}

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

@@ -1,45 +1,21 @@
-import { NULL_POINTER } from "../../BinaryTopology.js";
-import { bt_edge_create } from "./bt_edge_create.js";
-
-/**
- * Ensure an edge between two vertices
- * NOTE: works without having to use a separate hash map, resulting in faster execution and smaller RAM requirement
- * @param {BinaryTopology} mesh
- * @param {number} v0
- * @param {number} v1
- * @returns {number} edge ID
- */
-export function bt_edge_get_or_create(mesh, v0, v1) {
-    const first_edge = mesh.vertex_read_edge(v0);
-
-    if (first_edge !== NULL_POINTER) {
-
-        // iterate over all edges around the vertex
-        let edge = first_edge;
-
-        do {
-            const edge_v1 = mesh.edge_read_vertex1(edge);
-            const edge_v2 = mesh.edge_read_vertex2(edge);
-
-            if (edge_v1 === v1 || edge_v2 === v1) {
-                // found edge that connects between v0 and v1
-                return edge;
-            }
-
-            if (edge_v1 === v0) {
-                edge = mesh.edge_read_v1_disk_next(edge);
-            } else if (edge_v2 === v0) {
-                edge = mesh.edge_read_v2_disk_next(edge);
-            } else {
-                // invalid edge connection
-                throw new Error('Invalid edge, not connected to first vertex');
-            }
-
-        } while (edge !== first_edge);
-
-    }
-
-    // if match is found - return the match, else create a new edge and assign
-
-    return bt_edge_create(mesh, v0, v1);
-}
+import { NULL_POINTER } from "../../BinaryTopology.js";
+import { bt_edge_get } from "../../query/bt_edge_get.js";
+import { bt_edge_create } from "./bt_edge_create.js";
+
+/**
+ * Ensure an edge between two vertices
+ * NOTE: works without having to use a separate hash map, resulting in faster execution and smaller RAM requirement
+ * @param {BinaryTopology} mesh
+ * @param {number} v0
+ * @param {number} v1
+ * @returns {number} edge ID
+ */
+export function bt_edge_get_or_create(mesh, v0, v1) {
+    const existing = bt_edge_get(mesh, v0, v1);
+
+    if (existing !== NULL_POINTER) {
+        return existing;
+    }
+
+    return bt_edge_create(mesh, v0, v1);
+}

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

@@ -1 +1 @@
-{"version":3,"file":"bt_edge_kill.d.ts","sourceRoot":"","sources":["../../../../../../../../../../src/core/geom/3d/topology/struct/binary/io/edge/bt_edge_kill.js"],"names":[],"mappings":"AAMA;;;GAGG;AACH,sDAFW,MAAM,QAoBhB"}
+{"version":3,"file":"bt_edge_kill.d.ts","sourceRoot":"","sources":["../../../../../../../../../../src/core/geom/3d/topology/struct/binary/io/edge/bt_edge_kill.js"],"names":[],"mappings":"AAMA;;;GAGG;AACH,sDAFW,MAAM,QA0BhB"}

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

@@ -23,7 +23,13 @@ export function bt_edge_kill(mesh, e) {
     const v2 = mesh.edge_read_vertex2(e);
 
     bt_disk_edge_remove(mesh, e, v1);
-    bt_disk_edge_remove(mesh, e, v2);
+    if (v2 !== v1) {
+        // For self-loops the edge occupies a single slot in v's disk cycle
+        // (the v1 slot, per convention); the v2 slot is unused. Calling
+        // bt_disk_edge_remove again with the same vertex would be idempotent
+        // here, but the explicit guard documents the intent and saves a call.
+        bt_disk_edge_remove(mesh, e, v2);
+    }
 
     bt_kill_only_edge(mesh, e);
 }

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

@@ -1,12 +1,14 @@
 /**
  * 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} so that
- * {@link bt_vertex_replace} cannot produce a self-loop edge when a direct parallel
- * exists.
+ * itself alive.
  *
- * Adjacent faces of each killed parallel are removed as part of bt_edge_kill; the
- * return value reports how many were taken down so callers doing face-count
- * bookkeeping don't have to rescan.
+ * 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.

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

@@ -1 +1 @@
-{"version":3,"file":"bt_edge_kill_parallels.d.ts","sourceRoot":"","sources":["../../../../../../../../../../src/core/geom/3d/topology/struct/binary/io/edge/bt_edge_kill_parallels.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;GAaG;AACH,wEAHW,MAAM,GACJ,MAAM,CAyElB"}
+{"version":3,"file":"bt_edge_kill_parallels.d.ts","sourceRoot":"","sources":["../../../../../../../../../../src/core/geom/3d/topology/struct/binary/io/edge/bt_edge_kill_parallels.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;GAeG;AACH,wEAHW,MAAM,GACJ,MAAM,CAyElB"}

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

@@ -4,13 +4,15 @@ 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} so that
- * {@link bt_vertex_replace} cannot produce a self-loop edge when a direct parallel
- * exists.
+ * itself alive.
  *
- * Adjacent faces of each killed parallel are removed as part of bt_edge_kill; the
- * return value reports how many were taken down so callers doing face-count
- * bookkeeping don't have to rescan.
+ * 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.

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

@@ -0,0 +1,22 @@
+/**
+ * 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.
+ *
+ * @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: BinaryTopology, max_distance?: number): number;
+//# sourceMappingURL=bt_mesh_kill_short_edges.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"bt_mesh_kill_short_edges.d.ts","sourceRoot":"","sources":["../../../../../../../../../../src/core/geom/3d/topology/struct/binary/io/edge/bt_mesh_kill_short_edges.js"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,8EAJW,MAAM,GAEJ,MAAM,CA+ClB"}

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

@@ -0,0 +1,73 @@
+import { assert } from "../../../../../../../assert.js";
+import { v3_distance_sqr } from "../../../../../../vec3/v3_distance_sqr.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.
+ *
+ * @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 max_distance_sqr = max_distance * max_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/vertex/bt_vertex_replace.d.ts.map

@@ -1 +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"}
+{"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":"AAOA;;;;;;;;;;GAUG;AACH,gEAHW,MAAM,eACN,MAAM,QA8JhB"}

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

@@ -1,5 +1,7 @@
 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";
 
 const scratch_edges = new Uint32Array(1024);
 
@@ -69,7 +71,55 @@ export function bt_vertex_replace(
         }
 
         // --- Update Edge Vertices ---
-        const is_v1 = mesh.edge_read_vertex1(e) === victim;
+        // Three cases. Per the disk-cycle convention (see BinaryTopology.js
+        // __edge_pool comment), every edge occupies exactly one slot in each of
+        // its endpoints' cycles -- for self-loops that means one slot total, in
+        // the v1 slot of the unique endpoint's cycle.
+        //
+        //   (a) Normal: e was attached to victim only. Move the victim endpoint
+        //       onto replacement and splice e into replacement's cycle.
+        //   (b) Direct parallel: e connects victim and replacement. Becomes a
+        //       self-loop on replacement. e is already in replacement's disk on
+        //       the OTHER side; remove it there, update the vertex, then re-add
+        //       on the v1 side per convention.
+        //   (c) Self-loop on victim: e was a self-loop on victim. Becomes a
+        //       self-loop on replacement. Update BOTH vertex fields (the legacy
+        //       single-write path would have left vertex2 = victim, dangling
+        //       after bt_vert_kill(victim) runs upstream), then add to
+        //       replacement's cycle from scratch.
+        const e_v1 = mesh.edge_read_vertex1(e);
+        const e_v2 = mesh.edge_read_vertex2(e);
+        const is_v1 = e_v1 === victim;
+        const other_endpoint = is_v1 ? e_v2 : e_v1;
+
+        if (other_endpoint === victim) {
+            // case (c): self-loop on victim -> self-loop on replacement
+            mesh.edge_write_vertex1(e, replacement);
+            mesh.edge_write_vertex2(e, replacement);
+            bt_disk_edge_add(mesh, e, replacement);
+            continue;
+        }
+
+        if (other_endpoint === replacement) {
+            // case (b): direct parallel becoming a self-loop on replacement.
+            // e is currently in replacement's disk on the side OPPOSITE the
+            // victim side; remove it there before rewriting the vertex slot.
+            bt_disk_edge_remove(mesh, e, replacement);
+
+            if (is_v1) {
+                mesh.edge_write_vertex1(e, replacement);
+            } else {
+                mesh.edge_write_vertex2(e, replacement);
+            }
+
+            // Now e is a self-loop; bt_disk_edge_add will write the v1 slot
+            // per the convention.
+            bt_disk_edge_add(mesh, e, replacement);
+            continue;
+        }
+
+        // case (a): normal path. Move the victim endpoint onto replacement and
+        // splice e into replacement's cycle.
         if (is_v1) {
             mesh.edge_write_vertex1(e, replacement);
         } else {

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

@@ -0,0 +1,10 @@
+/**
+ * Find an existing edge between two vertices
+ * NOTE: works without having to use a separate hash map, resulting in faster execution and smaller RAM requirement
+ * @param {BinaryTopology} mesh
+ * @param {number} v0
+ * @param {number} v1
+ * @returns {number} edge ID, or {@link NULL_POINTER} if no such edge exists
+ */
+export function bt_edge_get(mesh: BinaryTopology, v0: number, v1: number): number;
+//# sourceMappingURL=bt_edge_get.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"bt_edge_get.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/core/geom/3d/topology/struct/binary/query/bt_edge_get.js"],"names":[],"mappings":"AAEA;;;;;;;GAOG;AACH,sDAJW,MAAM,MACN,MAAM,GACJ,MAAM,CAiClB"}

package/src/core/geom/3d/topology/struct/binary/query/bt_edge_get.js

@@ -0,0 +1,42 @@
+import { NULL_POINTER } from "../BinaryTopology.js";
+
+/**
+ * Find an existing edge between two vertices
+ * NOTE: works without having to use a separate hash map, resulting in faster execution and smaller RAM requirement
+ * @param {BinaryTopology} mesh
+ * @param {number} v0
+ * @param {number} v1
+ * @returns {number} edge ID, or {@link NULL_POINTER} if no such edge exists
+ */
+export function bt_edge_get(mesh, v0, v1) {
+    const first_edge = mesh.vertex_read_edge(v0);
+
+    if (first_edge === NULL_POINTER) {
+        return NULL_POINTER;
+    }
+
+    // iterate over all edges around the vertex
+    let edge = first_edge;
+
+    do {
+        const edge_v1 = mesh.edge_read_vertex1(edge);
+        const edge_v2 = mesh.edge_read_vertex2(edge);
+
+        if (edge_v1 === v1 || edge_v2 === v1) {
+            // found edge that connects between v0 and v1
+            return edge;
+        }
+
+        if (edge_v1 === v0) {
+            edge = mesh.edge_read_v1_disk_next(edge);
+        } else if (edge_v2 === v0) {
+            edge = mesh.edge_read_v2_disk_next(edge);
+        } else {
+            // invalid edge connection
+            throw new Error('Invalid edge, not connected to first vertex');
+        }
+
+    } while (edge !== first_edge);
+
+    return NULL_POINTER;
+}

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

@@ -0,0 +1,28 @@
+/**
+ * Sample interior Steiner points for the volume enclosed by a closed
+ * triangle surface, on a jittered axis-aligned grid sized by
+ * `cells_per_dim`. Points outside the surface are discarded; what remains
+ * is a Float32Array of (x, y, z) tuples that lies strictly inside the
+ * surface (modulo classification noise on near-surface samples).
+ *
+ * Intended as input to `compute_delaunay_tetrahedral_mesh` alongside the
+ * surface vertices, so the Delaunay tet mesh has interior detail rather
+ * than being made entirely of surface-bound tets. Without these Steiner
+ * points, every tet of a non-trivial volume straddles or touches the
+ * surface, blowing up centroid-classification discretization error in
+ * the carving step.
+ *
+ * Grid cells are scaled so the longest bounding-box axis gets
+ * `cells_per_dim` cells; other axes get a proportional share rounded to
+ * the nearest integer (minimum 1). Each cell contributes one candidate
+ * point at its center, perturbed by a deterministic seeded jitter of up
+ * to ±0.35 cell widths — enough to break Delaunay-pathological
+ * alignments without losing the grid's spatial uniformity.
+ *
+ * @param {BinaryTopology} mesh closed surface
+ * @param {number} cells_per_dim grid resolution along the longest bbox axis
+ * @param {number} [seed] seed for the jitter RNG; same seed → same points
+ * @returns {Float32Array} flat (x, y, z) interior point positions
+ */
+export function bt_mesh_sample_interior_grid_points(mesh: BinaryTopology, cells_per_dim: number, seed?: number): Float32Array;
+//# sourceMappingURL=bt_mesh_sample_interior_grid_points.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"bt_mesh_sample_interior_grid_points.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/core/geom/3d/topology/struct/binary/query/bt_mesh_sample_interior_grid_points.js"],"names":[],"mappings":"AA4HA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,yFAJW,MAAM,SACN,MAAM,GACJ,YAAY,CA8ExB"}