@woosh/meep-engine 3.30.0 → 3.31.0

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

@@ -80,6 +80,12 @@ export function bt_mesh_split_pinched_vertices(mesh) {
 
     const vertices = mesh.vertices;
 
+    /**
+     * Null until the mesh declares a vertex layer.
+     * @type {BinaryDataBlock|null}
+     */
+    const vertex_data = mesh.vertex_data;
+
     // Vertices added below are single-fan by construction, so the sweep only needs the original range.
     const vertex_count = vertices.size;
 
@@ -216,12 +222,18 @@ export function bt_mesh_split_pinched_vertices(mesh) {
 
             moved.add(group);
 
-            const replacement = vertices.allocate();
+            // `mesh.vertex_create()`, not `vertices.allocate()` - the topology owns element
+            // lifetime, and going round it leaves the vertex attribute block sized for the old pool
+            // capacity, so the new vertex has no record to read or write.
+            const replacement = mesh.vertex_create();
 
             mesh.vertex_write_coordinate(replacement, scratch_coordinate, 0);
             mesh.vertex_write_normal(replacement, scratch_normal, 0);
             mesh.vertex_write_edge(replacement, NULL_POINTER);
 
+            // the split vertex is a copy of the one it came from, so it inherits its attributes
+            vertex_data?.copy_record(replacement, vertex_data, vertex);
+
             added++;
 
             for (let k = 0; k < corner_group.length; k++) {

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

@@ -1 +1 @@
-{"version":3,"file":"bt_vertex_fuse_duplicate_edges.d.ts","sourceRoot":"","sources":["../../../../../../../../../../src/core/geom/3d/topology/struct/binary/io/vertex/bt_vertex_fuse_duplicate_edges.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wEAHW,MAAM,GACJ,MAAM,CAyHlB"}
+{"version":3,"file":"bt_vertex_fuse_duplicate_edges.d.ts","sourceRoot":"","sources":["../../../../../../../../../../src/core/geom/3d/topology/struct/binary/io/vertex/bt_vertex_fuse_duplicate_edges.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wEAHW,MAAM,GACJ,MAAM,CA2HlB"}

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

@@ -132,7 +132,9 @@ export function bt_vertex_fuse_duplicate_edges(mesh, v) {
                     bt_loop_kill(mesh, fl);
                     fl = mesh.face_read_loop(face_to_kill);
                 }
-                face_pool.release(face_to_kill);
+                // through the topology, not the pool - element lifetime is the topology's, and
+                // `face_destroy` is where the attribute block is kept in step
+                mesh.face_destroy(face_to_kill);
                 faces_killed++;
             }
 

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

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

@@ -1,9 +1,22 @@
-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);
+/**
+ * The victim's incident edges, collected before its disk cycles are mutated.
+ *
+ * Grown on demand, the way bt_mesh_append grows its corner buffer. It used to be a fixed 1024
+ * bounded only by an assert, which the consumer strips: past 1024 the typed-array write is
+ * silently dropped while the count keeps rising, so the second loop reads `undefined`,
+ * `element_address(undefined)` is NaN, and `DataView.getUint32(NaN)` coerces the offset to 0 —
+ * every overflow iteration then reads and rewrites the head of the edge pool and leaves the real
+ * edges dangling on a killed vertex. Silent topology corruption in the pass whose output is baked
+ * into a shipped .vgeo, and bt_mesh_simplify has no valence cap to keep a greedy collapse in a
+ * flat region from funnelling that much valence into one star vertex.
+ *
+ * @type {Uint32Array}
+ */
+let scratch_edges = new Uint32Array(1024);
 
 /**
  * Patch mesh structure to make all loops/edges/faces point to this new replacement vertex instead of the victim.
@@ -37,7 +50,13 @@ export function bt_vertex_replace(
         let start_e = curr_e;
         do {
 
-            assert.lessThan(edges_to_move_count, scratch_edges.length, "edges_to_move_count");
+            if (edges_to_move_count === scratch_edges.length) {
+                const grown = new Uint32Array(scratch_edges.length * 2);
+
+                grown.set(scratch_edges);
+
+                scratch_edges = grown;
+            }
 
             scratch_edges[edges_to_move_count++] = curr_e;
 

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

@@ -1,13 +1,28 @@
 /**
- * Number of loops on an edge's radial cycle, i.e. how many faces use that edge.
+ * Number of **live** faces on an edge's radial cycle.
  *
  * `0` is a wire edge, `1` a boundary edge, `2` a manifold interior edge, and `3`
  * or more a non-manifold edge. {@link bt_edge_is_boundary} answers the `1` case
  * on its own; this is the counting version the manifoldness queries need.
  *
+ * ## Orphan loops do not count
+ *
+ * A loop whose face has already been freed — by a prior edge collapse, or by
+ * {@link bt_kill_only_face}, which frees a face without untangling it — is still on the radial cycle
+ * but no longer describes a face using this edge. It is skipped.
+ *
+ * This used to count loops rather than faces, and `bt_mesh_simplify` and
+ * `bt_mesh_compute_vertex_quadrics` each carried a private live-face copy because of it, with
+ * `bt_edge_kill_parallels` inlining a third. So the exported, spec'd version was the one with the
+ * known-wrong behaviour and the private ones were the corrected ones, invisible to a grep for this
+ * name. On a mesh carrying orphan loops the loop count over-reported, which reads as a boundary edge
+ * being manifold — and `bt_mesh_is_manifold` and `bt_mesh_is_closed` sit directly on it.
+ *
  * The walk is bounded by the loop pool's size so a corrupted radial cycle cannot
  * hang the caller. A cycle that long is itself broken -- run
- * {@link bt_mesh_validate} to find out where.
+ * {@link bt_mesh_validate} to find out where. The bound is on steps taken rather than on faces
+ * counted, because a cycle made entirely of orphan loops counts nothing and would otherwise never
+ * reach it.
  *
  * @param {BinaryTopology} mesh
  * @param {number} edge_id

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

@@ -1 +1 @@
-{"version":3,"file":"bt_edge_count_faces.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/core/geom/3d/topology/struct/binary/query/bt_edge_count_faces.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;GAiBG;AACH,mEANW,MAAM,GACJ,MAAM,CAwBlB"}
+{"version":3,"file":"bt_edge_count_faces.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/core/geom/3d/topology/struct/binary/query/bt_edge_count_faces.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,mEANW,MAAM,GACJ,MAAM,CAiClB"}

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

@@ -1,15 +1,30 @@
 import { NULL_POINTER } from "../BinaryTopology.js";
 
 /**
- * Number of loops on an edge's radial cycle, i.e. how many faces use that edge.
+ * Number of **live** faces on an edge's radial cycle.
  *
  * `0` is a wire edge, `1` a boundary edge, `2` a manifold interior edge, and `3`
  * or more a non-manifold edge. {@link bt_edge_is_boundary} answers the `1` case
  * on its own; this is the counting version the manifoldness queries need.
  *
+ * ## Orphan loops do not count
+ *
+ * A loop whose face has already been freed — by a prior edge collapse, or by
+ * {@link bt_kill_only_face}, which frees a face without untangling it — is still on the radial cycle
+ * but no longer describes a face using this edge. It is skipped.
+ *
+ * This used to count loops rather than faces, and `bt_mesh_simplify` and
+ * `bt_mesh_compute_vertex_quadrics` each carried a private live-face copy because of it, with
+ * `bt_edge_kill_parallels` inlining a third. So the exported, spec'd version was the one with the
+ * known-wrong behaviour and the private ones were the corrected ones, invisible to a grep for this
+ * name. On a mesh carrying orphan loops the loop count over-reported, which reads as a boundary edge
+ * being manifold — and `bt_mesh_is_manifold` and `bt_mesh_is_closed` sit directly on it.
+ *
  * The walk is bounded by the loop pool's size so a corrupted radial cycle cannot
  * hang the caller. A cycle that long is itself broken -- run
- * {@link bt_mesh_validate} to find out where.
+ * {@link bt_mesh_validate} to find out where. The bound is on steps taken rather than on faces
+ * counted, because a cycle made entirely of orphan loops counts nothing and would otherwise never
+ * reach it.
  *
  * @param {BinaryTopology} mesh
  * @param {number} edge_id
@@ -25,16 +40,25 @@ export function bt_edge_count_faces(mesh, edge_id) {
         return 0;
     }
 
+    const face_pool = mesh.faces;
+
     const limit = mesh.loops.size;
 
     let l = start;
     let count = 0;
+    let steps = 0;
 
     do {
-        count++;
+        const face = mesh.loop_read_face(l);
+
+        if (face !== NULL_POINTER && face_pool.is_allocated(face)) {
+            count++;
+        }
+
+        steps++;
 
         l = mesh.loop_read_radial_next(l);
-    } while (l !== start && l !== NULL_POINTER && count <= limit);
+    } while (l !== start && l !== NULL_POINTER && steps <= limit);
 
     return count;
 }

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

@@ -1 +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"}
+{"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,CAwClB"}

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

@@ -22,7 +22,14 @@ export function bt_edge_get(mesh, v0, v1) {
         const edge_v1 = mesh.edge_read_vertex1(edge);
         const edge_v2 = mesh.edge_read_vertex2(edge);
 
-        if (edge_v1 === v1 || edge_v2 === v1) {
+        // Match the endpoints as an unordered pair. Testing only for `v1` without excluding `v0`
+        // made every edge on the disk match when `v0 === v1`, so a self-loop query answered with an
+        // unrelated incident edge and `bt_edge_get_or_create` handed it to the caller instead of
+        // creating the self-loop - attaching a loop to an edge that does not span its corner.
+        if (
+            (edge_v1 === v0 && edge_v2 === v1)
+            || (edge_v1 === v1 && edge_v2 === v0)
+        ) {
             // found edge that connects between v0 and v1
             return edge;
         }

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

@@ -1 +1 @@
-{"version":3,"file":"bt_face_get_edge_adjacent_faces_weighted.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/core/geom/3d/topology/struct/binary/query/bt_face_get_edge_adjacent_faces_weighted.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,iEATW,MAAM,EAAE,GAAC,WAAW,6BACpB,MAAM,EAAE,GAAC,WAAW,iBAEpB,MAAM,iCAEN,MAAM,GACJ,MAAM,CAqElB"}
+{"version":3,"file":"bt_face_get_edge_adjacent_faces_weighted.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/core/geom/3d/topology/struct/binary/query/bt_face_get_edge_adjacent_faces_weighted.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,iEATW,MAAM,EAAE,GAAC,WAAW,6BACpB,MAAM,EAAE,GAAC,WAAW,iBAEpB,MAAM,iCAEN,MAAM,GACJ,MAAM,CA6ElB"}

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

@@ -57,8 +57,16 @@ export function bt_face_get_edge_adjacent_faces_weighted(
         while (radial_loop !== current_loop) {
             const neighbor_face = mesh.loop_read_face(radial_loop);
 
-            // Ensure we aren't adding the original face itself
-            if (neighbor_face !== face_id) {
+            /*
+             Not the original face, and a face at all. An ORPHAN loop — one whose face was killed,
+             which bt_mesh_validate reports as LOOP_ORPHANED — reads NULL_POINTER here, and that
+             used to fall straight through the `!== face_id` test and be emitted as neighbour
+             4294967295. bt_face_island_flood_fill pushes what this returns onto its frontier, and
+             the next iteration asks that id for its loops: face_read_loop(0xFFFFFFFF) is a
+             RangeError out of the DataView. The vertex-adjacent sibling tests both, so the two
+             disagreed about the same case.
+            */
+            if (neighbor_face !== face_id && neighbor_face !== NULL_POINTER) {
 
                 // Where we already recorded this face, if we have (linear scan
                 // is fastest for the small neighbour counts faces actually have)

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

@@ -1 +1 @@
-{"version":3,"file":"bt_face_island_flood_fill.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/core/geom/3d/topology/struct/binary/query/bt_face_island_flood_fill.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;GAcG;AACH,4EALW,UAAU,MAAM,CAAC,OACjB,MAAM,EAAE,oBAEN,MAAM,CA2BlB"}
+{"version":3,"file":"bt_face_island_flood_fill.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/core/geom/3d/topology/struct/binary/query/bt_face_island_flood_fill.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;GAcG;AACH,4EALW,UAAU,MAAM,CAAC,OACjB,MAAM,EAAE,oBAEN,MAAM,CA6BlB"}

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

@@ -36,6 +36,8 @@ export function bt_face_island_flood_fill(mesh, seed_faces, out, visited) {
         const neighbour_count = bt_face_get_edge_adjacent_faces(_neighbours, 0, mesh, f);
         for (let i = 0; i < neighbour_count; i++) {
             const g = _neighbours[i];
+            // the same check the seeds get: a frontier is no safer than a seed
+            if (!faces.is_allocated(g)) continue;
             if (visited.getAndSet(g)) continue;
             open.push(g);
         }

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

@@ -1 +1 @@
-{"version":3,"file":"bt_mesh_build_boundary_distance_field.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/core/geom/3d/topology/struct/binary/query/bt_mesh_build_boundary_distance_field.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;GAYG;AACH,iFALW,IAAI,MAAM,EAAE,MAAM,CAAC,yCAEnB,IAAI,MAAM,CAAC,qBACX,IAAI,MAAM,CAAC,QAuIrB"}
+{"version":3,"file":"bt_mesh_build_boundary_distance_field.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/core/geom/3d/topology/struct/binary/query/bt_mesh_build_boundary_distance_field.js"],"names":[],"mappings":"AAsBA;;;;;;;;;;;;GAYG;AACH,iFALW,IAAI,MAAM,EAAE,MAAM,CAAC,yCAEnB,IAAI,MAAM,CAAC,qBACX,IAAI,MAAM,CAAC,QAyIrB"}

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

@@ -1,7 +1,25 @@
-import { Uint32Heap } from "../../../../../../collection/heap/Uint32Heap.js";
+import { IndexedFloatMinHeap } from "../../../../../../collection/heap/IndexedFloatMinHeap.js";
 import { NULL_POINTER } from "../BinaryTopology.js";
 import { bt_mesh_compute_edge_distance_eikonal } from "./bt_mesh_compute_edge_distance_eikonal.js";
 
+/**
+ * Relax `vertex` to `distance`, admitting it to the frontier if it is not already on it.
+ *
+ * One call on a queue that answers `contains` by scanning; two on one that keeps an index,
+ * because the index is what makes the question cheap enough to ask separately.
+ *
+ * @param {IndexedFloatMinHeap} heap
+ * @param {number} vertex
+ * @param {number} distance
+ */
+function relax(heap, vertex, distance) {
+    if (heap.contains(vertex)) {
+        heap.update(vertex, distance);
+    } else {
+        heap.insert(vertex, distance);
+    }
+}
+
 /**
  * Build distance field for a given island (group of faces).
  * Distances are calculated as shortest from the boundary.
@@ -22,7 +40,9 @@ export function bt_mesh_build_boundary_distance_field(
     boundary_vertices
 ) {
 
-    const heap = new Uint32Heap(island_vertices.size);
+    // Keyed by vertex id, so the index spans the vertex pool — `island_vertices.size` is a
+    // cardinality, and only ever sized the allocation, which is what it still does here.
+    const heap = new IndexedFloatMinHeap(mesh.vertices.size, island_vertices.size);
 
     // initialize distances
     for (const v of island_vertices) {
@@ -36,7 +56,7 @@ export function bt_mesh_build_boundary_distance_field(
 
     const scratch_vertex = new Float32Array(3);
 
-    while (!heap.is_empty()) {
+    while (heap.size !== 0) {
         const current_vertex = heap.pop_min();
         const current_distance = vertex_boundary_distances.get(current_vertex);
 
@@ -80,7 +100,7 @@ export function bt_mesh_build_boundary_distance_field(
             // Update v_other if the direct edge path is shorter than what it currently has
             if (new_neighbor_dist < other_distance) {
                 vertex_boundary_distances.set(v_other, new_neighbor_dist);
-                heap.insert_or_update(v_other, new_neighbor_dist);
+                relax(heap, v_other, new_neighbor_dist);
                 // Update local variable so STEP B uses the tighter bound immediately
                 other_distance = new_neighbor_dist;
             }
@@ -134,7 +154,7 @@ export function bt_mesh_build_boundary_distance_field(
 
                             if (new_distance < existing_distance) {
                                 vertex_boundary_distances.set(v_target, new_distance);
-                                heap.insert_or_update(v_target, new_distance);
+                                relax(heap, v_target, new_distance);
                             }
                         }
 

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

@@ -11,6 +11,10 @@
  * @param {number} c_x
  * @param {number} c_y
  * @param {number} c_z
+ * @returns {boolean} `false` when the triangle has no area and the written
+ *   value is the arbitrary placeholder rather than a real normal. Callers that
+ *   only want a direction can go on ignoring it; one that ACCUMULATES normals
+ *   has to know, because a placeholder that votes is a vote for nothing.
  */
-export function tri3_compute_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;
+export function tri3_compute_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): boolean;
 //# sourceMappingURL=tri3_compute_normal.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"tri3_compute_normal.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/triangle/tri3_compute_normal.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;GAaG;AACH,4CAZW,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"}
+{"version":3,"file":"tri3_compute_normal.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/triangle/tri3_compute_normal.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;GAiBG;AACH,4CAhBW,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,GACJ,OAAO,CAgDnB"}

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

@@ -13,6 +13,10 @@ import { v3_length_sqr } from "../../vec3/v3_length_sqr.js";
  * @param {number} c_x
  * @param {number} c_y
  * @param {number} c_z
+ * @returns {boolean} `false` when the triangle has no area and the written
+ *   value is the arbitrary placeholder rather than a real normal. Callers that
+ *   only want a direction can go on ignoring it; one that ACCUMULATES normals
+ *   has to know, because a placeholder that votes is a vote for nothing.
  */
 export function tri3_compute_normal(
     result, result_offset,
@@ -42,7 +46,8 @@ export function tri3_compute_normal(
         result[result_offset] = 0;
         result[result_offset + 1] = 1;
         result[result_offset + 2] = 0;
-        return;
+
+        return false;
     }
 
     const l_inv = 1 / Math.sqrt(l_sqr);
@@ -54,4 +59,6 @@ export function tri3_compute_normal(
     result[result_offset] = x;
     result[result_offset + 1] = y;
     result[result_offset + 2] = z;
+
+    return true;
 }

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

@@ -1 +1 @@
-{"version":3,"file":"tri3_ray_intersection.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/triangle/tri3_ray_intersection.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,uEAjBW,MAAM,YACN,MAAM,YACN,MAAM,eACN,MAAM,eACN,MAAM,eACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,OAAO,CAwInB"}
+{"version":3,"file":"tri3_ray_intersection.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/triangle/tri3_ray_intersection.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,uEAjBW,MAAM,YACN,MAAM,YACN,MAAM,eACN,MAAM,eACN,MAAM,eACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,OAAO,CAoJnB"}

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

@@ -143,10 +143,22 @@ export function tri3_ray_intersection(
     // Ray intersects triangle.
     const t = QdN / DdN;
 
+    // `normal_x/y/z` is the raw `edge1 x edge2`, whose length is twice the triangle's area - it was
+    // written straight into `SurfacePoint3.normal`, which is documented as a surface normal and is
+    // a unit vector out of every other producer in the tree.
+    //
+    // NOTE: normalised but NOT turned to meet the ray, unlike `tri3_raycast`. This normal keeps the
+    // winding's facing on purpose: `StaticSceneBVH.raycast_nearest` derives `geometric_back_face`
+    // from `dot(normal, direction)`, and a normal pre-flipped toward the ray would report every hit
+    // as front-facing.
+    const normal_length = Math.sqrt(normal_x * normal_x + normal_y * normal_y + normal_z * normal_z);
+
+    const inv_normal_length = 1 / normal_length;
+
     result.normal.set(
-        normal_x,
-        normal_y,
-        normal_z
+        normal_x * inv_normal_length,
+        normal_y * inv_normal_length,
+        normal_z * inv_normal_length
     );
 
     result.position.set(

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

@@ -3,7 +3,8 @@
  * NOTE:  most of the code is inlined for speed to avoid allocation and function calls
  * @see https://github.com/erich666/jgt-code/blob/master/Volume_02/Number_1/Moller1997a/raytri.c
  * @source https://en.wikipedia.org/wiki/M%C3%B6ller%E2%80%93Trumbore_intersection_algorithm (Möller and Trumbore, « Fast, Minimum Storage Ray-Triangle Intersection », Journal of Graphics Tools, vol. 2,‎ 1997, p. 21–28)
- * @param {number[]} result [t,u,v, normal_x, normal_y, normal_z] will be written here
+ * @param {number[]} result [t, u, v] is written here. NOTE: only those three - an earlier version of
+ * this doc promised a normal in slots 3..5, which nothing has ever written.
  * @param {number} origin_x
  * @param {number} origin_y
  * @param {number} origin_z

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

@@ -1 +1 @@
-{"version":3,"file":"tri3_ray_intersection_barycentric.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/triangle/tri3_ray_intersection_barycentric.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,0DAlBW,MAAM,EAAE,YACR,MAAM,YACN,MAAM,YACN,MAAM,eACN,MAAM,eACN,MAAM,eACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,OAAO,CAqEnB"}
+{"version":3,"file":"tri3_ray_intersection_barycentric.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/triangle/tri3_ray_intersection_barycentric.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,0DAnBW,MAAM,EAAE,YAER,MAAM,YACN,MAAM,YACN,MAAM,eACN,MAAM,eACN,MAAM,eACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,OAAO,CAqEnB"}

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

@@ -6,7 +6,8 @@ import { tri3_ray_intersection_barycentric_edge } from "./tri3_ray_intersection_
  * NOTE:  most of the code is inlined for speed to avoid allocation and function calls
  * @see https://github.com/erich666/jgt-code/blob/master/Volume_02/Number_1/Moller1997a/raytri.c
  * @source https://en.wikipedia.org/wiki/M%C3%B6ller%E2%80%93Trumbore_intersection_algorithm (Möller and Trumbore, « Fast, Minimum Storage Ray-Triangle Intersection », Journal of Graphics Tools, vol. 2,‎ 1997, p. 21–28)
- * @param {number[]} result [t,u,v, normal_x, normal_y, normal_z] will be written here
+ * @param {number[]} result [t, u, v] is written here. NOTE: only those three - an earlier version of
+ * this doc promised a normal in slots 3..5, which nothing has ever written.
  * @param {number} origin_x
  * @param {number} origin_y
  * @param {number} origin_z

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

@@ -4,7 +4,7 @@
  * NOTE:  most of the code is inlined for speed to avoid allocation and function calls
  * @see https://github.com/erich666/jgt-code/blob/master/Volume_02/Number_1/Moller1997a/raytri.c
  * @source https://en.wikipedia.org/wiki/M%C3%B6ller%E2%80%93Trumbore_intersection_algorithm (Möller and Trumbore, « Fast, Minimum Storage Ray-Triangle Intersection », Journal of Graphics Tools, vol. 2,‎ 1997, p. 21–28)
- * @param {number[]} result
+ * @param {number[]} result [t, u, v] is written here, and only on a hit
  * @param {number} origin_x
  * @param {number} origin_y
  * @param {number} origin_z

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

@@ -1 +1 @@
-{"version":3,"file":"tri3_ray_intersection_barycentric_edge.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/triangle/tri3_ray_intersection_barycentric_edge.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,+DAlBW,MAAM,EAAE,YACR,MAAM,YACN,MAAM,YACN,MAAM,eACN,MAAM,eACN,MAAM,eACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,WACN,MAAM,WACN,MAAM,WACN,MAAM,WACN,MAAM,WACN,MAAM,WACN,MAAM,GACL,OAAO,CAsElB"}
+{"version":3,"file":"tri3_ray_intersection_barycentric_edge.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/triangle/tri3_ray_intersection_barycentric_edge.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,+DAlBW,MAAM,EAAE,YACR,MAAM,YACN,MAAM,YACN,MAAM,eACN,MAAM,eACN,MAAM,eACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,WACN,MAAM,WACN,MAAM,WACN,MAAM,WACN,MAAM,WACN,MAAM,WACN,MAAM,GACL,OAAO,CA6ElB"}

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

@@ -6,7 +6,7 @@ import { v3_dot } from "../../vec3/v3_dot.js";
  * NOTE:  most of the code is inlined for speed to avoid allocation and function calls
  * @see https://github.com/erich666/jgt-code/blob/master/Volume_02/Number_1/Moller1997a/raytri.c
  * @source https://en.wikipedia.org/wiki/M%C3%B6ller%E2%80%93Trumbore_intersection_algorithm (Möller and Trumbore, « Fast, Minimum Storage Ray-Triangle Intersection », Journal of Graphics Tools, vol. 2,‎ 1997, p. 21–28)
- * @param {number[]} result
+ * @param {number[]} result [t, u, v] is written here, and only on a hit
  * @param {number} origin_x
  * @param {number} origin_y
  * @param {number} origin_z
@@ -87,6 +87,13 @@ export function tri3_ray_intersection_barycentric_edge(
     // calculate t, scale parameter, ray intersects triangle
     const t = v3_dot(edge2_x, edge2_y, edge2_z, qvec_x, qvec_y, qvec_z) * inv_det;
 
+    if (t < 0) {
+        // Behind the ray origin. This is a ray test, not a line test - writing `t` unconditionally
+        // answered the line question, and every in-tree caller had to re-derive this check by hand.
+        // Both siblings reject it: `tri3_ray_intersection` on `QdN < 0`, `tri3_raycast` on `t < 0`.
+        return false;
+    }
+
     result[0] = t;
     result[1] = u ;
     result[2] = v ;

package/src/core/geom/vec/vector_normalize.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"vector_normalize.d.ts","sourceRoot":"","sources":["../../../../../src/core/geom/vec/vector_normalize.js"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,yCAJW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,QAClC,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,WAClC,MAAM,QAoBhB"}
+{"version":3,"file":"vector_normalize.d.ts","sourceRoot":"","sources":["../../../../../src/core/geom/vec/vector_normalize.js"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,yCAJW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,QAClC,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,WAClC,MAAM,QAwBhB"}

package/src/core/geom/vec/vector_normalize.js

@@ -16,7 +16,11 @@ export function vector_normalize(result, data, length = data.length) {
         magnitude2 += value2;
     }
 
-    const magnitude_inv = 1 / Math.sqrt(magnitude2);
+    // avoid division by 0 — a zero vector normalises to itself rather than to NaN. The two
+    // fixed-dimension siblings, v2_array_normalize and v3_normalize_array, are written to this same
+    // shape and both carry this guard; this one divided unconditionally, so 1/sqrt(0) is Infinity
+    // and 0 * Infinity is NaN in every component.
+    const magnitude_inv = magnitude2 !== 0 ? 1 / Math.sqrt(magnitude2) : 1;
 
     for (let i = 0; i < length; i++) {
         result[i] = data[i] * magnitude_inv;

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

@@ -1 +1 @@
-{"version":3,"file":"v3_slerp.d.ts","sourceRoot":"","sources":["../../../../../src/core/geom/vec3/v3_slerp.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;GAYG;AACH,iCATW,UAAQ;IAAC,GAAG,CAAC,CAAC,EAAC,MAAM,EAAC,CAAC,EAAC,MAAM,EAAC,CAAC,EAAC,MAAM,EAAC;CAAC,OACzC,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,YACN,MAAM,QAwChB"}
+{"version":3,"file":"v3_slerp.d.ts","sourceRoot":"","sources":["../../../../../src/core/geom/vec3/v3_slerp.js"],"names":[],"mappings":"AAWA;;;;;;;;;;;;GAYG;AACH,iCATW,UAAQ;IAAC,GAAG,CAAC,CAAC,EAAC,MAAM,EAAC,CAAC,EAAC,MAAM,EAAC,CAAC,EAAC,MAAM,EAAC;CAAC,OACzC,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,YACN,MAAM,QAkGhB"}

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

@@ -2,6 +2,13 @@ import { assert } from "../../assert.js";
 import { v3_dot } from "./v3_dot.js";
 import { v3_lerp } from "./v3_lerp.js";
 
+/**
+ * Dot product at or below which two directions count as antipodal. `sin(acos(dot))` is around 4.5e-4
+ * here, which is where the general slerp formula starts losing precision to its own division.
+ * @type {number}
+ */
+const ANTIPODAL_DOT = -1 + 1e-7;
+
 /**
  * Spherical linear interpolation
  * NOTE: vectors are assumed to be normalized
@@ -30,12 +37,72 @@ export function v3_slerp(
         b_x, b_y, b_z
     );
 
-    if (dot >= 1 || dot <= -1) {
-        // avoid division by 0, both vectors are pointing in the same direction, use lerp instead
+    if (dot >= 1) {
+        // both vectors point the same way, the arc has no length - lerp stays on the sphere
         v3_lerp(result, a_x, a_y, a_z, b_x, b_y, b_z, fraction);
         return;
     }
 
+    if (dot <= ANTIPODAL_DOT) {
+        // Antipodal. `sin(theta)` is zero here, so the general formula below divides by zero, and
+        // lerping instead passes the result through the origin - at fraction 0.5 it returns
+        // (0,0,0), which is not a direction at all. The arc is not unique in this case, so pick any
+        // unit vector orthogonal to `a` and rotate through it by `fraction * PI`.
+
+        // endpoints exactly, rather than through cos/sin - sin(PI) is 1.2e-16, not 0, and the
+        // inputs need not have equal length
+        if (fraction <= 0) {
+            result.set(a_x, a_y, a_z);
+            return;
+        } else if (fraction >= 1) {
+            result.set(b_x, b_y, b_z);
+            return;
+        }
+
+        const abs_x = Math.abs(a_x);
+        const abs_y = Math.abs(a_y);
+        const abs_z = Math.abs(a_z);
+
+        // cross `a` with whichever principal axis it is least aligned with, so the product is well
+        // conditioned whatever direction `a` points in
+        let o_x, o_y, o_z;
+
+        if (abs_x <= abs_y && abs_x <= abs_z) {
+            o_x = 0;
+            o_y = -a_z;
+            o_z = a_y;
+        } else if (abs_y <= abs_z) {
+            o_x = -a_z;
+            o_y = 0;
+            o_z = a_x;
+        } else {
+            o_x = -a_y;
+            o_y = a_x;
+            o_z = 0;
+        }
+
+        const o_length = Math.sqrt(o_x * o_x + o_y * o_y + o_z * o_z);
+
+        const inv_o_length = 1 / o_length;
+
+        o_x *= inv_o_length;
+        o_y *= inv_o_length;
+        o_z *= inv_o_length;
+
+        const angle = Math.PI * fraction;
+
+        const c = Math.cos(angle);
+        const s = Math.sin(angle);
+
+        result.set(
+            a_x * c + o_x * s,
+            a_y * c + o_y * s,
+            a_z * c + o_z * s
+        );
+
+        return;
+    }
+
     // compute angle between two vectors
     const theta = Math.acos(dot);
 
@@ -43,8 +110,6 @@ export function v3_slerp(
 
     const inv_sin_theta = 1 / sin_theta;
 
-    // TODO check for sin_theta == 0 to avoid division by 0
-
     const scale_0 = Math.sin((1 - fraction) * theta) * inv_sin_theta;
     const scale_1 = Math.sin((fraction) * theta) * inv_sin_theta;
 

package/src/core/geom/vec4/v4_max_axis.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Index of the largest of four components: `0` for x, `1` for y, `2` for z, `3` for w.
+ *
+ * The CPU twin of `chunk_v4_max_axis`, written as the same comparison chain so that the two break ties
+ * the same way. That matters more than it looks: `quat3_encode_to_uint32` and its WGSL mirror
+ * `quat_encode_u32` use this to choose which quaternion component to *drop*, and on a tie they used to
+ * choose differently — for `|x| = |y| = 0.6`, `|z| = |w| = 0.1` the CPU dropped x and the GPU dropped y,
+ * so the same quaternion encoded to two different words. Both still decode correctly, because the dropped
+ * index travels in the low two bits, so nothing broke until something compared a CPU-encoded row against
+ * a GPU-encoded one.
+ *
+ * The tie rule, stated: the first component that is strictly greater than every component after it wins,
+ * so on a tie the *later* index is chosen. `(0.6, 0.6, 0.1, 0.1)` answers `1`.
+ *
+ * NaN in any component makes every comparison false, so the answer is `3`. That is the chunk's behaviour
+ * as well, and not a judgement about what a caller should want.
+ *
+ * @param {number} x
+ * @param {number} y
+ * @param {number} z
+ * @param {number} w
+ * @returns {number} `0..3`
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function v4_max_axis(x: number, y: number, z: number, w: number): number;
+//# sourceMappingURL=v4_max_axis.d.ts.map