@woosh/meep-engine 2.139.0 → 2.140.0

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

@@ -1,11 +1,11 @@
 import { assert } from "../../../assert.js";
+import {
+    tetrahedral_mesh_build_vertex_to_tets_map
+} from "./tetrahedral_mesh_build_vertex_to_tets_map.js";
 import { compute_tetrahedron_quality } from "./compute_tetrahedron_quality.js";
 import {
     tetrahedral_mesh_find_tets_around_edge
 } from "./tetrahedral_mesh_find_tets_around_edge.js";
-import {
-    tetrahedral_mesh_find_tets_attached_to_vertex
-} from "./tetrahedral_mesh_find_tets_attached_to_vertex.js";
 import { tetrahedral_mesh_flip_23 } from "./tetrahedral_mesh_flip_23.js";
 import { tetrahedral_mesh_flip_32 } from "./tetrahedral_mesh_flip_32.js";
 import {
@@ -27,14 +27,12 @@ const FACE_VERTICES_BY_OPPOSITE = [
     [0, 1, 2],
 ];
 
-// Scratch for the 2-3 / 3-2 flip out-parameters and for collecting tets
-// during local quality re-evaluation. Module-level — the driver is not
-// re-entrant.
+// Scratch for the 2-3 / 3-2 flip out-parameters. Module-level — the driver
+// is not re-entrant.
 const scratch_out_23 = new Uint32Array(3);
 const scratch_out_32 = new Uint32Array(2);
 const scratch_edge_ring = new Array(16);
 const scratch_ring_closed = [0];
-let scratch_local_tets = new Array(64);
 
 // The 6 unique vertex-pair (i, j) slots in a 4-vertex tet, enumerating
 // every edge once. Used to iterate the 6 edges of a candidate tet during
@@ -122,6 +120,13 @@ export function tetrahedral_mesh_improve_quality(mesh, points, options = {}) {
         // delete and re-introduce tet IDs underneath us.
         const live = mesh.getLive();
 
+        // Build a vertex->tets cache once per pass. Used by the boundary
+        // check (flip-invariant — safe to use for the whole pass) and by
+        // the local quality eval (filtered through mesh.exists; may miss
+        // newly-flipped tets which is fine: the live-snapshot iteration
+        // already misses them too, and they'll be picked up next pass).
+        const vertex_to_tets = tetrahedral_mesh_build_vertex_to_tets_map(mesh);
+
         for (let li = 0; li < live.length; li++) {
             const tet = live[li];
             if (!mesh.exists(tet)) continue;
@@ -134,19 +139,19 @@ export function tetrahedral_mesh_improve_quality(mesh, points, options = {}) {
                 for (let i = 0; i < 4; i++) {
                     if (!mesh.exists(tet)) break;
                     const v_id = mesh.getVertexIndex(tet, i);
-                    if (tetrahedral_mesh_vertex_is_boundary(mesh, v_id)) continue;
+                    if (tetrahedral_mesh_vertex_is_boundary(mesh, v_id, vertex_to_tets)) continue;
 
                     const v3 = v_id * 3;
                     const old_x = points[v3];
                     const old_y = points[v3 + 1];
                     const old_z = points[v3 + 2];
 
-                    const old_min = local_min_quality_around_vertex(mesh, points, v_id);
+                    const old_min = local_min_quality_around_vertex(mesh, points, v_id, vertex_to_tets);
 
-                    const moved = tetrahedral_mesh_smooth_vertex(mesh, points, v_id, smoothing_weight);
+                    const moved = tetrahedral_mesh_smooth_vertex(mesh, points, v_id, smoothing_weight, vertex_to_tets);
                     if (!moved) continue;
 
-                    const new_min = local_min_quality_around_vertex(mesh, points, v_id);
+                    const new_min = local_min_quality_around_vertex(mesh, points, v_id, vertex_to_tets);
                     if (new_min > old_min) {
                         stats.smoothings_committed++;
                         any_improvement = true;
@@ -349,16 +354,33 @@ function scan_min_quality(mesh, points) {
 /**
  * Min quality across all tets containing `v_id`. Used to score the local
  * effect of moving (or undoing the move of) a single vertex.
+ *
+ * Reads the incident tets directly from the pass-level cache and filters
+ * out tets that have since been deleted. Cache entries whose vertex set
+ * no longer contains `v_id` (because a flip re-used the slot) are
+ * silently skipped — those tets are no longer part of `v_id`'s 1-ring
+ * anyway.
  */
-function local_min_quality_around_vertex(mesh, points, v_id) {
-    if (scratch_local_tets.length < mesh.count) {
-        scratch_local_tets = new Array(Math.max(mesh.count, scratch_local_tets.length * 2));
-    }
-    const n = tetrahedral_mesh_find_tets_attached_to_vertex(scratch_local_tets, 0, mesh, v_id);
+function local_min_quality_around_vertex(mesh, points, v_id, vertex_to_tets) {
+    const tets = vertex_to_tets.get(v_id);
+    if (tets === undefined) return 1;
 
     let min_q = 1;
-    for (let i = 0; i < n; i++) {
-        const q = compute_tetrahedron_quality(mesh, points, scratch_local_tets[i]);
+    for (let i = 0; i < tets.length; i++) {
+        const tet = tets[i];
+        if (!mesh.exists(tet)) continue;
+        // Tet may have been re-used by a flip with a different vertex set;
+        // confirm v_id is still incident before counting it.
+        let still_incident = false;
+        for (let s = 0; s < 4; s++) {
+            if (mesh.getVertexIndex(tet, s) === v_id) {
+                still_incident = true;
+                break;
+            }
+        }
+        if (!still_incident) continue;
+
+        const q = compute_tetrahedron_quality(mesh, points, tet);
         if (q < min_q) min_q = q;
     }
     return min_q;

package/src/core/geom/3d/tetrahedra/tetrahedral_mesh_smooth_vertex.d.ts

@@ -6,10 +6,13 @@
  * Mutates `points` in place. Does NOT touch the mesh topology.
  *
  * The 1-ring is computed by finding every tet that contains `vertex_id` and
- * collecting the OTHER 3 vertices of each tet, deduplicated. For typical
- * meshes this is fast; for very heavy use over many vertices in tight
- * loops, build a vertex-to-tet adjacency map once and call a lower-level
- * smoothing primitive instead.
+ * collecting the OTHER 3 vertices of each tet, deduplicated.
+ *
+ * If `vertex_to_tets_map` is provided (a `Map<vertex_id, tet_id[]>` from
+ * {@link tetrahedral_mesh_build_vertex_to_tets_map}), the incident-tet
+ * lookup runs in O(deg) instead of O(N). Entries pointing to deleted tets
+ * or to tets that no longer contain `vertex_id` (e.g. flipped) are
+ * silently filtered.
  *
  * Does NOT check whether the vertex sits on the mesh boundary — the caller
  * is responsible for skipping boundary vertices (via
@@ -25,7 +28,8 @@
  * @param {Float32Array|number[]} points flat (x,y,z) positions — mutated in place
  * @param {number} vertex_id
  * @param {number} [weight] move fraction, default 1.0
+ * @param {Map<number, number[]>} [vertex_to_tets_map] optional adjacency cache
  * @returns {boolean} true if `points` was modified
  */
-export function tetrahedral_mesh_smooth_vertex(mesh: TetrahedralMesh, points: Float32Array | number[], vertex_id: number, weight?: number): boolean;
+export function tetrahedral_mesh_smooth_vertex(mesh: TetrahedralMesh, points: Float32Array | number[], vertex_id: number, weight?: number, vertex_to_tets_map?: Map<number, number[]>): boolean;
 //# sourceMappingURL=tetrahedral_mesh_smooth_vertex.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"tetrahedral_mesh_smooth_vertex.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/tetrahedra/tetrahedral_mesh_smooth_vertex.js"],"names":[],"mappings":"AAWA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,8EALW,YAAY,GAAC,MAAM,EAAE,aACrB,MAAM,WACN,MAAM,GACJ,OAAO,CAyEnB"}
+{"version":3,"file":"tetrahedral_mesh_smooth_vertex.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/tetrahedra/tetrahedral_mesh_smooth_vertex.js"],"names":[],"mappings":"AAWA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,8EANW,YAAY,GAAC,MAAM,EAAE,aACrB,MAAM,WACN,MAAM,uBACN,IAAI,MAAM,EAAE,MAAM,EAAE,CAAC,GACnB,OAAO,CAiGnB"}

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

@@ -17,10 +17,13 @@ let scratch_neighbours = new Array(128);
  * Mutates `points` in place. Does NOT touch the mesh topology.
  *
  * The 1-ring is computed by finding every tet that contains `vertex_id` and
- * collecting the OTHER 3 vertices of each tet, deduplicated. For typical
- * meshes this is fast; for very heavy use over many vertices in tight
- * loops, build a vertex-to-tet adjacency map once and call a lower-level
- * smoothing primitive instead.
+ * collecting the OTHER 3 vertices of each tet, deduplicated.
+ *
+ * If `vertex_to_tets_map` is provided (a `Map<vertex_id, tet_id[]>` from
+ * {@link tetrahedral_mesh_build_vertex_to_tets_map}), the incident-tet
+ * lookup runs in O(deg) instead of O(N). Entries pointing to deleted tets
+ * or to tets that no longer contain `vertex_id` (e.g. flipped) are
+ * silently filtered.
  *
  * Does NOT check whether the vertex sits on the mesh boundary — the caller
  * is responsible for skipping boundary vertices (via
@@ -36,9 +39,10 @@ let scratch_neighbours = new Array(128);
  * @param {Float32Array|number[]} points flat (x,y,z) positions — mutated in place
  * @param {number} vertex_id
  * @param {number} [weight] move fraction, default 1.0
+ * @param {Map<number, number[]>} [vertex_to_tets_map] optional adjacency cache
  * @returns {boolean} true if `points` was modified
  */
-export function tetrahedral_mesh_smooth_vertex(mesh, points, vertex_id, weight = 1.0) {
+export function tetrahedral_mesh_smooth_vertex(mesh, points, vertex_id, weight = 1.0, vertex_to_tets_map) {
     assert.defined(mesh, 'mesh');
     assert.defined(points, 'points');
     assert.isNonNegativeInteger(vertex_id, 'vertex_id');
@@ -47,12 +51,36 @@ export function tetrahedral_mesh_smooth_vertex(mesh, points, vertex_id, weight =
     if (weight === 0) return false;
 
     // 1. Find tets containing the vertex.
-    if (scratch_tets.length < mesh.count) {
-        scratch_tets = new Array(Math.max(mesh.count, scratch_tets.length * 2));
+    let tet_count;
+    if (vertex_to_tets_map !== undefined) {
+        const cached = vertex_to_tets_map.get(vertex_id);
+        if (cached === undefined) return false;
+        if (scratch_tets.length < cached.length) {
+            scratch_tets = new Array(Math.max(cached.length, scratch_tets.length * 2));
+        }
+        // Filter stale entries (deleted tets, or tets that no longer
+        // contain vertex_id because a flip re-used the slot).
+        tet_count = 0;
+        for (let i = 0; i < cached.length; i++) {
+            const tet = cached[i];
+            if (!mesh.exists(tet)) continue;
+            let still_incident = false;
+            for (let s = 0; s < 4; s++) {
+                if (mesh.getVertexIndex(tet, s) === vertex_id) {
+                    still_incident = true;
+                    break;
+                }
+            }
+            if (still_incident) scratch_tets[tet_count++] = tet;
+        }
+    } else {
+        if (scratch_tets.length < mesh.count) {
+            scratch_tets = new Array(Math.max(mesh.count, scratch_tets.length * 2));
+        }
+        tet_count = tetrahedral_mesh_find_tets_attached_to_vertex(
+            scratch_tets, 0, mesh, vertex_id
+        );
     }
-    const tet_count = tetrahedral_mesh_find_tets_attached_to_vertex(
-        scratch_tets, 0, mesh, vertex_id
-    );
 
     if (tet_count === 0) return false;
 

package/src/core/geom/3d/tetrahedra/tetrahedral_mesh_vertex_is_boundary.d.ts

@@ -8,15 +8,24 @@
  * external surface (which usually represents some geometric constraint
  * the caller wants preserved).
  *
- * Cost: O(N) over the live tets, same as
+ * Cost without `vertex_to_tets_map`: O(N) over the live tets, same as
  * {@link tetrahedral_mesh_find_tets_attached_to_vertex} which it shares
- * the same scan structure with. For repeated calls over many vertices,
- * caller should precompute a boundary bitset rather than calling this in
- * a loop.
+ * the same scan structure with.
+ *
+ * Cost with `vertex_to_tets_map`: O(deg(vertex)) — usually a small
+ * constant. For repeated calls over many vertices in a tight loop
+ * (e.g. a sliver-removal pass), build the map once via
+ * {@link tetrahedral_mesh_build_vertex_to_tets_map} and pass it in.
+ *
+ * Note: boundary status is invariant under interior 2-3 / 3-2 flips, so
+ * a once-per-pass cache stays valid for boundary queries even as the
+ * pass commits flips, as long as a freshly-snapshotted cache is built
+ * for each NEW pass.
  *
  * @param {TetrahedralMesh} mesh
  * @param {number} vertex_id
+ * @param {Map<number, number[]>} [vertex_to_tets_map] optional cache
  * @returns {boolean}
  */
-export function tetrahedral_mesh_vertex_is_boundary(mesh: TetrahedralMesh, vertex_id: number): boolean;
+export function tetrahedral_mesh_vertex_is_boundary(mesh: TetrahedralMesh, vertex_id: number, vertex_to_tets_map?: Map<number, number[]>): boolean;
 //# sourceMappingURL=tetrahedral_mesh_vertex_is_boundary.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"tetrahedral_mesh_vertex_is_boundary.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/tetrahedra/tetrahedral_mesh_vertex_is_boundary.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,sFAHW,MAAM,GACJ,OAAO,CAiCnB"}
+{"version":3,"file":"tetrahedral_mesh_vertex_is_boundary.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/tetrahedra/tetrahedral_mesh_vertex_is_boundary.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,sFAJW,MAAM,uBACN,IAAI,MAAM,EAAE,MAAM,EAAE,CAAC,GACnB,OAAO,CAkEnB"}

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

@@ -11,20 +11,62 @@ import { INVALID_NEIGHBOUR } from "./TetrahedralMesh.js";
  * external surface (which usually represents some geometric constraint
  * the caller wants preserved).
  *
- * Cost: O(N) over the live tets, same as
+ * Cost without `vertex_to_tets_map`: O(N) over the live tets, same as
  * {@link tetrahedral_mesh_find_tets_attached_to_vertex} which it shares
- * the same scan structure with. For repeated calls over many vertices,
- * caller should precompute a boundary bitset rather than calling this in
- * a loop.
+ * the same scan structure with.
+ *
+ * Cost with `vertex_to_tets_map`: O(deg(vertex)) — usually a small
+ * constant. For repeated calls over many vertices in a tight loop
+ * (e.g. a sliver-removal pass), build the map once via
+ * {@link tetrahedral_mesh_build_vertex_to_tets_map} and pass it in.
+ *
+ * Note: boundary status is invariant under interior 2-3 / 3-2 flips, so
+ * a once-per-pass cache stays valid for boundary queries even as the
+ * pass commits flips, as long as a freshly-snapshotted cache is built
+ * for each NEW pass.
  *
  * @param {TetrahedralMesh} mesh
  * @param {number} vertex_id
+ * @param {Map<number, number[]>} [vertex_to_tets_map] optional cache
  * @returns {boolean}
  */
-export function tetrahedral_mesh_vertex_is_boundary(mesh, vertex_id) {
+export function tetrahedral_mesh_vertex_is_boundary(mesh, vertex_id, vertex_to_tets_map) {
     assert.defined(mesh, 'mesh');
     assert.isNonNegativeInteger(vertex_id, 'vertex_id');
 
+    if (vertex_to_tets_map !== undefined) {
+        const tets = vertex_to_tets_map.get(vertex_id);
+        if (tets === undefined) return false;
+
+        for (let ti = 0; ti < tets.length; ti++) {
+            const tet = tets[ti];
+            // Tets in the cache may have been deleted since it was built.
+            if (!mesh.exists(tet)) continue;
+
+            // Find the slot of vertex_id in this tet — present by
+            // construction unless a flip re-used the tet ID with
+            // different vertices, in which case skip.
+            let v_slot = -1;
+            for (let i = 0; i < 4; i++) {
+                if (mesh.getVertexIndex(tet, i) === vertex_id) {
+                    v_slot = i;
+                    break;
+                }
+            }
+            if (v_slot < 0) continue;
+
+            // The 3 faces containing vertex_id are the ones NOT opposite v_slot.
+            for (let j = 0; j < 4; j++) {
+                if (j === v_slot) continue;
+                if (mesh.getNeighbour(tet, j) === INVALID_NEIGHBOUR) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
+    // Slow path: scan every live tet.
     let is_boundary = false;
 
     mesh.forEach((tet, m) => {

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

@@ -66,6 +66,17 @@ export class BinaryElementPool implements Iterable<number> {
      * @private
      */
     private __capacity;
+    /**
+     * Occupancy index: bit `id` is 1 when slot `id` is allocated, 0 when
+     * free. Lets {@link is_allocated} answer in O(1) instead of scanning
+     * {@link __free}. The {@link __free} stack remains the allocator; this
+     * is purely a membership accelerator kept in lockstep with it.
+     * `preventShrink` stops the bitset reallocating smaller when top slots
+     * are cleared — its capacity tracks the pool, not the live set.
+     * @type {BitSet}
+     * @private
+     */
+    private __occupancy;
     /**
      *
      * @param {ArrayBuffer} buffer
@@ -193,6 +204,14 @@ export class BinaryElementPool implements Iterable<number> {
      * @param {BinaryElementPool} other
      */
     copy(other: BinaryElementPool): void;
+    /**
+     * Rebuild the occupancy index from `__size` and the current free set:
+     * every id in `[0, size)` is allocated except those held in `__free`.
+     * Used after {@link copy}, where the data buffer and free set are adopted
+     * wholesale.
+     * @private
+     */
+    private __rebuild_occupancy_from_free;
     /**
      * Used for type checking
      * @readonly

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

@@ -1 +1 @@
-{"version":3,"file":"BinaryElementPool.d.ts","sourceRoot":"","sources":["../../../../../../../../src/core/geom/3d/topology/struct/binary/BinaryElementPool.js"],"names":[],"mappings":"AA2BA;;;GAGG;AACH,mDAFyB,MAAM;IA0B3B;;;;;OAKG;IACH,uBAJW,MAAM,qBACN,MAAM,sBACN,OAAO,EAkDjB;IA5ED;;;;OAIG;IACH,eAAY;IAEZ;;;;;OAKG;IACH,uBAAmB;IAEnB;;;;OAIG;IACH,eAAW;IAeP;;;;OAIG;IACH,oBAA4B;IAG5B;;;;OAIG;IACH,sBAA8F;IAC9F;;;;OAIG;IACH,qBAAsD;IACtD;;;;OAIG;IACH,sBAAwD;IACxD;;;;OAIG;IACH,uBAA0D;IAC1D,oBAAiD;IAEjD;;;;OAIG;IACH,mBAAkC;IAItC;;;;OAIG;IACH,wBAHW,WAAW,2BACX,MAAM,QAsBhB;IAED;;;OAGG;IACH,+BAEC;IAED;;;OAGG;IACH,wBAEC;IAED;;;;OAIG;IACH,mBAEC;IAED;;;OAGG;IACH,uBAEC;IAED;;;OAGG;IACH,uBAEC;IAGD;;;OAGG;IACH,+BAEC;IAED;;;OAGG;IACH,iCAEC;IAED;;OAEG;IACH,aAEC;IAED;;;;OAIG;IACH,oBAHW,MAAM,GACL,MAAM,CAMjB;IAED;;;;;OAKG;IACH,iBAHW,MAAM,GACL,MAAM,CAIjB;IAED;;;;OAIG;IACH,iBAHW,MAAM,GACL,OAAO,CAsBlB;IAED;;;;OAIG;IACH,uBAwBC;IAED;;;;OAIG;IACH,wBAQC;IAED;;;OAGG;IACH,0BAFW,MAAM,QAMhB;IAGD;;;OAGG;IACH,YAFY,MAAM,CAqBjB;IAED;;;;OAIG;IACH,2BAHW,MAAM,GACL,MAAM,CAcjB;IAED;;;;;OAKG;IACH,QAHW,MAAM,KACN,MAAM,QAiBhB;IAED;;;;OAIG;IACH,YAFW,MAAM,QAYhB;IAED;;OAEG;IACH,uBAEC;IAED;;;;;OAKG;IACH,mBAFW,MAAM,QAQhB;IAED;;;OAGG;IACH,cAGC;IAED;;;OAGG;IACH,YAFW,iBAAiB,QA0B3B;IAoBL;;;;OAIG;IACH,8BAFU,OAAO,CAE8B;IAvB3C;;;OAGG;IACH,qBAFY,UAAU,MAAM,CAAC,CAa5B;CACJ"}
+{"version":3,"file":"BinaryElementPool.d.ts","sourceRoot":"","sources":["../../../../../../../../src/core/geom/3d/topology/struct/binary/BinaryElementPool.js"],"names":[],"mappings":"AA4BA;;;GAGG;AACH,mDAFyB,MAAM;IA0B3B;;;;;OAKG;IACH,uBAJW,MAAM,qBACN,MAAM,sBACN,OAAO,EA+DjB;IAzFD;;;;OAIG;IACH,eAAY;IAEZ;;;;;OAKG;IACH,uBAAmB;IAEnB;;;;OAIG;IACH,eAAW;IAeP;;;;OAIG;IACH,oBAA4B;IAG5B;;;;OAIG;IACH,sBAA8F;IAC9F;;;;OAIG;IACH,qBAAsD;IACtD;;;;OAIG;IACH,sBAAwD;IACxD;;;;OAIG;IACH,uBAA0D;IAC1D,oBAAiD;IAEjD;;;;OAIG;IACH,mBAAkC;IAElC;;;;;;;;;OASG;IACH,oBAA8C;IAKlD;;;;OAIG;IACH,wBAHW,WAAW,2BACX,MAAM,QA8BhB;IAED;;;OAGG;IACH,+BAEC;IAED;;;OAGG;IACH,wBAEC;IAED;;;;OAIG;IACH,mBAEC;IAED;;;OAGG;IACH,uBAEC;IAED;;;OAGG;IACH,uBAEC;IAGD;;;OAGG;IACH,+BAEC;IAED;;;OAGG;IACH,iCAEC;IAED;;OAEG;IACH,aAEC;IAED;;;;OAIG;IACH,oBAHW,MAAM,GACL,MAAM,CAMjB;IAED;;;;;OAKG;IACH,iBAHW,MAAM,GACL,MAAM,CAIjB;IAED;;;;OAIG;IACH,iBAHW,MAAM,GACL,OAAO,CAYlB;IAED;;;;OAIG;IACH,uBA2BC;IAED;;;;OAIG;IACH,wBAQC;IAED;;;OAGG;IACH,0BAFW,MAAM,QAMhB;IAGD;;;OAGG;IACH,YAFY,MAAM,CAyBjB;IAED;;;;OAIG;IACH,2BAHW,MAAM,GACL,MAAM,CAmBjB;IAED;;;;;OAKG;IACH,QAHW,MAAM,KACN,MAAM,QAiBhB;IAED;;;;OAIG;IACH,YAFW,MAAM,QAchB;IAED;;OAEG;IACH,uBAOC;IAED;;;;;OAKG;IACH,mBAFW,MAAM,QAchB;IAED;;;OAGG;IACH,cAIC;IAED;;;OAGG;IACH,YAFW,iBAAiB,QA4B3B;IAED;;;;;;OAMG;IACH,sCAaC;IAoBL;;;;OAIG;IACH,8BAFU,OAAO,CAE8B;IAvB3C;;;OAGG;IACH,qBAFY,UAAU,MAAM,CAAC,CAa5B;CACJ"}

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

@@ -1,5 +1,6 @@
 import { assert } from "../../../../../assert.js";
 import { align_4 } from "../../../../../binary/align_4.js";
+import { BitSet } from "../../../../../binary/BitSet.js";
 import { makeArrayBuffer } from "../../../../../binary/makeArrayBuffer.js";
 import { array_swap } from "../../../../../collection/array/array_swap.js";
 import { array_buffer_copy } from "../../../../../collection/array/typed/array_buffer_copy.js";
@@ -107,6 +108,19 @@ export class BinaryElementPool {
          */
         this.__capacity = initial_capacity;
 
+        /**
+         * Occupancy index: bit `id` is 1 when slot `id` is allocated, 0 when
+         * free. Lets {@link is_allocated} answer in O(1) instead of scanning
+         * {@link __free}. The {@link __free} stack remains the allocator; this
+         * is purely a membership accelerator kept in lockstep with it.
+         * `preventShrink` stops the bitset reallocating smaller when top slots
+         * are cleared — its capacity tracks the pool, not the live set.
+         * @type {BitSet}
+         * @private
+         */
+        this.__occupancy = new BitSet(this.__capacity);
+        this.__occupancy.preventShrink();
+
     }
 
     /**
@@ -134,6 +148,14 @@ export class BinaryElementPool {
         // drop free slots
         this.__free_pointer = 0;
         this.__size = allocated_record_count;
+
+        // Rebuild occupancy for the adopted buffer: the free set is dropped, so
+        // exactly [0, allocated_record_count) is allocated.
+        this.__occupancy = new BitSet(capacity);
+        this.__occupancy.preventShrink();
+        if (allocated_record_count > 0) {
+            this.__occupancy.setRange(0, allocated_record_count - 1);
+        }
     }
 
     /**
@@ -235,18 +257,8 @@ export class BinaryElementPool {
             return false;
         }
 
-        const pointer = this.__free_pointer;
-
-        for (let i = 0; i < pointer; i++) {
-            const _id = this.__free[i];
-
-            if (id === _id) {
-                // found in unallocated set
-                return false;
-            }
-        }
-
-        return true;
+        // O(1) occupancy bit read.
+        return this.__occupancy.get(id);
     }
 
     /**
@@ -278,6 +290,9 @@ export class BinaryElementPool {
         typed_array_copy(old_data_uint8, this.__data_uint8);
 
         this.__capacity = new_capacity;
+
+        // The bitset self-manages capacity on set(); preventShrink keeps it from
+        // dropping below the used region on clears. Nothing to do here.
     }
 
     /**
@@ -314,7 +329,9 @@ export class BinaryElementPool {
         if (this.__free_pointer > 0) {
             // get unused slot
             this.__free_pointer--;
-            return this.__free[this.__free_pointer];
+            const id = this.__free[this.__free_pointer];
+            this.__occupancy.set(id, true);
+            return id;
         }
 
         // allocate new
@@ -328,6 +345,8 @@ export class BinaryElementPool {
 
         // assert.greaterThan(this.__data_buffer.byteLength, result * this.__item_size, 'memory underflow');
 
+        this.__occupancy.set(result, true);
+
         return result;
     }
 
@@ -347,6 +366,11 @@ export class BinaryElementPool {
 
         // assert.greaterThanOrEqual(this.__data_buffer.byteLength, (offset + count) * this.__item_size, 'memory underflow');
 
+        // Mark the whole range allocated.
+        if (count > 0) {
+            this.__occupancy.setRange(offset, offset + count - 1);
+        }
+
         return offset;
     }
 
@@ -382,11 +406,13 @@ export class BinaryElementPool {
         if (id === this.__size - 1) {
             // releasing item at the end of the reserved region, don't have to push it into free set
             this.__size--;
+            this.__occupancy.set(id, false);
         } else if (id >= this.__size) {
             // do nothing, just throw it away
             // this should never happen
         } else {
             this.__free[this.__free_pointer++] = id;
+            this.__occupancy.set(id, false);
         }
     }
 
@@ -395,6 +421,11 @@ export class BinaryElementPool {
      */
     clear_free_set() {
         this.__free_pointer = 0;
+
+        // With the free set empty, every slot in [0, size) is allocated again.
+        if (this.__size > 0) {
+            this.__occupancy.setRange(0, this.__size - 1);
+        }
     }
 
     /**
@@ -409,6 +440,12 @@ export class BinaryElementPool {
 
         this.__size = new_size;
         this.__free_pointer = 0;
+
+        // Free set discarded: [0, new_size) is the live region with no holes.
+        this.__occupancy.reset();
+        if (new_size > 0) {
+            this.__occupancy.setRange(0, new_size - 1);
+        }
     }
 
     /**
@@ -418,6 +455,7 @@ export class BinaryElementPool {
     clear() {
         this.__size = 0;
         this.__free_pointer = 0;
+        this.__occupancy.reset();
     }
 
     /**
@@ -448,6 +486,30 @@ export class BinaryElementPool {
 
         this.__free_pointer = other.__free_pointer;
         this.__free = other.__free.slice();
+
+        this.__rebuild_occupancy_from_free();
+    }
+
+    /**
+     * Rebuild the occupancy index from `__size` and the current free set:
+     * every id in `[0, size)` is allocated except those held in `__free`.
+     * Used after {@link copy}, where the data buffer and free set are adopted
+     * wholesale.
+     * @private
+     */
+    __rebuild_occupancy_from_free() {
+        this.__occupancy = new BitSet(Math.max(this.__capacity, this.__size));
+        this.__occupancy.preventShrink();
+
+        if (this.__size > 0) {
+            this.__occupancy.setRange(0, this.__size - 1);
+        }
+
+        const free = this.__free;
+        const pointer = this.__free_pointer;
+        for (let i = 0; i < pointer; i++) {
+            this.__occupancy.set(free[i], false);
+        }
     }
 
     /**

package/src/core/geom/3d/triangle/v3_compute_triangle_normal.d.ts

@@ -1,6 +1,6 @@
 /**
  * Compute face normal for a triangle
- * @param {number[]|Float32Array} result X,Y,Z normalized vector is written here
+ * @param {number[]|Float32Array|Float64Array} result X,Y,Z normalized vector is written here
  * @param {number} result_offset offset into result array where to start writing
  * @param {number} a_x
  * @param {number} a_y
@@ -12,5 +12,5 @@
  * @param {number} c_y
  * @param {number} c_z
  */
-export function v3_compute_triangle_normal(result: number[] | Float32Array, result_offset: number, a_x: number, a_y: number, a_z: number, b_x: number, b_y: number, b_z: number, c_x: number, c_y: number, c_z: number): void;
+export function v3_compute_triangle_normal(result: number[] | Float32Array | Float64Array, result_offset: number, a_x: number, a_y: number, a_z: number, b_x: number, b_y: number, b_z: number, c_x: number, c_y: number, c_z: number): void;
 //# sourceMappingURL=v3_compute_triangle_normal.d.ts.map

package/src/core/geom/3d/triangle/v3_compute_triangle_normal.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"v3_compute_triangle_normal.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/triangle/v3_compute_triangle_normal.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;GAaG;AACH,mDAZW,MAAM,EAAE,GAAC,YAAY,iBACrB,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,QA0ChB"}
+{"version":3,"file":"v3_compute_triangle_normal.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/triangle/v3_compute_triangle_normal.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;GAaG;AACH,mDAZW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,iBAClC,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,QA0ChB"}

package/src/core/geom/3d/triangle/v3_compute_triangle_normal.js

@@ -2,7 +2,7 @@ import { v3_length_sqr } from "../../vec3/v3_length_sqr.js";
 
 /**
  * Compute face normal for a triangle
- * @param {number[]|Float32Array} result X,Y,Z normalized vector is written here
+ * @param {number[]|Float32Array|Float64Array} result X,Y,Z normalized vector is written here
  * @param {number} result_offset offset into result array where to start writing
  * @param {number} a_x
  * @param {number} a_y

package/src/core/geom/vec3/v3_dot_array_array.d.ts

@@ -1,10 +1,10 @@
 /**
  *
- * @param {number[]|Float32Array} a
+ * @param {number[]|Float32Array|Float64Array} a
  * @param {number} a_offset
- * @param {number[]|Float32Array} b
+ * @param {number[]|Float32Array|Float64Array} b
  * @param {number} b_offset
  * @returns {number}
  */
-export function v3_dot_array_array(a: number[] | Float32Array, a_offset: number, b: number[] | Float32Array, b_offset: number): number;
+export function v3_dot_array_array(a: number[] | Float32Array | Float64Array, a_offset: number, b: number[] | Float32Array | Float64Array, b_offset: number): number;
 //# sourceMappingURL=v3_dot_array_array.d.ts.map

package/src/core/geom/vec3/v3_dot_array_array.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"v3_dot_array_array.d.ts","sourceRoot":"","sources":["../../../../../src/core/geom/vec3/v3_dot_array_array.js"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,sCANW,MAAM,EAAE,GAAC,YAAY,YACrB,MAAM,KACN,MAAM,EAAE,GAAC,YAAY,YACrB,MAAM,GACJ,MAAM,CAgBlB"}
+{"version":3,"file":"v3_dot_array_array.d.ts","sourceRoot":"","sources":["../../../../../src/core/geom/vec3/v3_dot_array_array.js"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,sCANW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,YAClC,MAAM,KACN,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,YAClC,MAAM,GACJ,MAAM,CAgBlB"}

package/src/core/geom/vec3/v3_dot_array_array.js

@@ -1,8 +1,8 @@
 /**
  *
- * @param {number[]|Float32Array} a
+ * @param {number[]|Float32Array|Float64Array} a
  * @param {number} a_offset
- * @param {number[]|Float32Array} b
+ * @param {number[]|Float32Array|Float64Array} b
  * @param {number} b_offset
  * @returns {number}
  */

package/src/core/geom/vec3/v3_negate_array.d.ts

@@ -1,9 +1,9 @@
 /**
  *
- * @param {number[]|Float32Array} result
+ * @param {number[]|Float32Array|Float64Array} result
  * @param {number} result_offset
- * @param {number[]|Float32Array} input
+ * @param {number[]|Float32Array|Float64Array} input
  * @param {number} input_offset
  */
-export function v3_negate_array(result: number[] | Float32Array, result_offset: number, input: number[] | Float32Array, input_offset: number): void;
+export function v3_negate_array(result: number[] | Float32Array | Float64Array, result_offset: number, input: number[] | Float32Array | Float64Array, input_offset: number): void;
 //# sourceMappingURL=v3_negate_array.d.ts.map

package/src/core/geom/vec3/v3_negate_array.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"v3_negate_array.d.ts","sourceRoot":"","sources":["../../../../../src/core/geom/vec3/v3_negate_array.js"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,wCALW,MAAM,EAAE,GAAC,YAAY,iBACrB,MAAM,SACN,MAAM,EAAE,GAAC,YAAY,gBACrB,MAAM,QAUhB"}
+{"version":3,"file":"v3_negate_array.d.ts","sourceRoot":"","sources":["../../../../../src/core/geom/vec3/v3_negate_array.js"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,wCALW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,iBAClC,MAAM,SACN,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,gBAClC,MAAM,QAUhB"}

package/src/core/geom/vec3/v3_negate_array.js

@@ -1,8 +1,8 @@
 /**
  *
- * @param {number[]|Float32Array} result
+ * @param {number[]|Float32Array|Float64Array} result
  * @param {number} result_offset
- * @param {number[]|Float32Array} input
+ * @param {number[]|Float32Array|Float64Array} input
  * @param {number} input_offset
  */
 export function v3_negate_array(result, result_offset, input, input_offset) {