@woosh/meep-engine 3.30.0 → 3.32.0

package/src/core/fsm/simple/SimpleStateMachineDescription.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SimpleStateMachineDescription.d.ts","sourceRoot":"","sources":["../../../../../src/core/fsm/simple/SimpleStateMachineDescription.js"],"names":[],"mappings":"AAGA;;;;;;;;GAQG;AACH;IACI;;;;OAIG;IACH,iBAAwB;IAExB;;;;OAIG;IACH,gBAAa;IAEb;;;;OAIG;IACH,kBAAe;IAGf;;;;OAIG;IACH,wBAHW,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,uBAQjC;IAED;;;;OAIG;IACH,eAHW,MAAM,GACJ,OAAO,CAOnB;IAED;;;;;OAKG;IACH,cAJW,MAAM,KACN,MAAM,GACJ,OAAO,CAanB;IAED;;;OAGG;IACH,iBAHW,MAAM,GACJ,MAAM,CASlB;IAED;;;;OAIG;IACH,cAHW,MAAM,KACN,MAAM,QAgBhB;IAED;;;;OAIG;IACH,oBAHW,MAAM,sBACM,MAAM,QAQ5B;IAED;;;;OAIG;IACH,yBAHW,MAAM,GACJ,MAAM,EAAE,CAYpB;IAED;;;;OAIG;IACH,yBAHW,MAAM,GACJ,MAAM,EAAE,CAiBpB;IAED;;;;;OAKG;IACH,gBAJW,MAAM,QACN,MAAM,GACJ,MAAM,EAAE,GAAC,IAAI,CA+DzB;IAIL;;;OAGG;IACH,0CAFU,OAAO,CAEsD;CAPtE"}
+{"version":3,"file":"SimpleStateMachineDescription.d.ts","sourceRoot":"","sources":["../../../../../src/core/fsm/simple/SimpleStateMachineDescription.js"],"names":[],"mappings":"AAGA;;;;;;;;GAQG;AACH;IACI;;;;OAIG;IACH,iBAAwB;IAExB;;;;OAIG;IACH,gBAAa;IAEb;;;;OAIG;IACH,kBAAe;IAGf;;;;OAIG;IACH,wBAHW,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,uBAQjC;IAED;;;;OAIG;IACH,eAHW,MAAM,GACJ,OAAO,CAOnB;IAED;;;;;OAKG;IACH,cAJW,MAAM,KACN,MAAM,GACJ,OAAO,CAanB;IAED;;;OAGG;IACH,iBAHW,MAAM,GACJ,MAAM,CASlB;IAED;;;;OAIG;IACH,cAHW,MAAM,KACN,MAAM,QAiBhB;IAED;;;;OAIG;IACH,oBAHW,MAAM,sBACM,MAAM,QAQ5B;IAED;;;;OAIG;IACH,yBAHW,MAAM,GACJ,MAAM,EAAE,CAYpB;IAED;;;;OAIG;IACH,yBAHW,MAAM,GACJ,MAAM,EAAE,CAiBpB;IAED;;;;;OAKG;IACH,gBAJW,MAAM,QACN,MAAM,GACJ,MAAM,EAAE,GAAC,IAAI,CA+DzB;IAIL;;;OAGG;IACH,0CAFU,OAAO,CAEsD;CAPtE"}

package/src/core/fsm/simple/SimpleStateMachineDescription.js

@@ -97,15 +97,16 @@ export class SimpleStateMachineDescription {
     createEdge(a, b) {
         // assert.ok(this.stateExists(a), `state ${a} doesn't exist`);
         // assert.ok(this.stateExists(b), `state ${b} doesn't exist`);
-        // assert.notOk(this.edgeExists(a, b), `Edge '${a}' -> '${b}' already exists`);
-
         const edges = this.__edges;
 
         const targetStates = edges[a];
 
         if (targetStates === undefined) {
             edges[a] = [b]
-        } else {
+        } else if (targetStates.indexOf(b) === -1) {
+            // The edge set is a set, not a multiset. Pushing a duplicate made `advance` read
+            // `targetNodes.length !== 1` as an ambiguous choice, so two initialisation paths wiring
+            // the same transition left the machine silently refusing to move.
             targetStates.push(b);
         }
     }

package/src/core/geom/2d/convex-hull/convex_hull_fixed_count_2d_bruteforce.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"convex_hull_fixed_count_2d_bruteforce.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/2d/convex-hull/convex_hull_fixed_count_2d_bruteforce.js"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;GAcG;AACH,8DAVW,MAAM,EAAE,GAAC,YAAY,iBACrB,MAAM,sBACN,MAAM,gBACN,MAAM,EAAE,qBACR,MAAM,GACJ,MAAM,CA0IlB"}
+{"version":3,"file":"convex_hull_fixed_count_2d_bruteforce.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/2d/convex-hull/convex_hull_fixed_count_2d_bruteforce.js"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;GAcG;AACH,8DAVW,MAAM,EAAE,GAAC,YAAY,iBACrB,MAAM,sBACN,MAAM,gBACN,MAAM,EAAE,qBACR,MAAM,GACJ,MAAM,CA+IlB"}

package/src/core/geom/2d/convex-hull/convex_hull_fixed_count_2d_bruteforce.js

@@ -108,7 +108,12 @@ export function convex_hull_fixed_count_2d_bruteforce(
         }
 
         // we got intersection points, lets compute area
-        const area = polygon2_signed_area(intersections, k);
+        //
+        // NOTE: the magnitude, not the signed value. Every candidate for a clockwise input is
+        // negative, and `area < best_area` on a negative score selects the *largest* polygon -
+        // which is the opposite of what this function is for, with nothing to indicate it went
+        // wrong. Taking the magnitude makes the search winding-independent.
+        const area = Math.abs(polygon2_signed_area(intersections, k));
 
         if (area < best_area) {
             array_copy(intersections, 0, output, output_offset, k << 1);

package/src/core/geom/2d/convex-hull/convex_hull_fixed_count_2d_relaxation.d.ts

@@ -9,7 +9,7 @@
  * @param {number[]|Float32Array} output result will be written here
  * @param {number} output_offset offset into output array where to write the result
  * @param {number} output_point_count number of points to comprise bounding polygon
- * @param {number[]} input_points Points to be bounded, must be an ordered loop
+ * @param {number[]} input_points Points to be bounded, must be an ordered loop. Winding is not significant - both orders give the same result
  * @param {number} input_point_count number of points in the input to consider
  * @returns {number} actual number of points, this can be lower because input polygon has too few points
  */

package/src/core/geom/2d/convex-hull/convex_hull_fixed_count_2d_relaxation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"convex_hull_fixed_count_2d_relaxation.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/2d/convex-hull/convex_hull_fixed_count_2d_relaxation.js"],"names":[],"mappings":"AAmLA;;;;;;;;;;;;;;GAcG;AACH,8DAPW,MAAM,EAAE,GAAC,YAAY,iBACrB,MAAM,sBACN,MAAM,gBACN,MAAM,EAAE,qBACR,MAAM,GACJ,MAAM,CA+FlB"}
+{"version":3,"file":"convex_hull_fixed_count_2d_relaxation.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/2d/convex-hull/convex_hull_fixed_count_2d_relaxation.js"],"names":[],"mappings":"AAkLA;;;;;;;;;;;;;;GAcG;AACH,8DAPW,MAAM,EAAE,GAAC,YAAY,iBACrB,MAAM,sBACN,MAAM,gBACN,MAAM,EAAE,qBACR,MAAM,GACJ,MAAM,CA+FlB"}

package/src/core/geom/2d/convex-hull/convex_hull_fixed_count_2d_relaxation.js

@@ -162,12 +162,11 @@ function compute_collapse_cost(edge, vertex_buffer) {
         v0x, v0y, v2_temp[0], v2_temp[1], v1x, v1y
     );
 
-    //
-    // if (area < 0 || Number.isNaN(area)) {
-    //     debugger;
-    // }
-
-    return area;
+    // NOTE: the magnitude, not the signed value. The heap pops the minimum cost, and every cost
+    // for a clockwise input is negative - so the greedy pass took the most expensive collapse
+    // first and ran away into an essentially unbounded polygon. Taking the magnitude makes the
+    // cost winding-independent.
+    return Math.abs(area);
 }
 
 /**
@@ -188,7 +187,7 @@ const RETRY_MAX_COUNT = 1000;
  * @param {number[]|Float32Array} output result will be written here
  * @param {number} output_offset offset into output array where to write the result
  * @param {number} output_point_count number of points to comprise bounding polygon
- * @param {number[]} input_points Points to be bounded, must be an ordered loop
+ * @param {number[]} input_points Points to be bounded, must be an ordered loop. Winding is not significant - both orders give the same result
  * @param {number} input_point_count number of points in the input to consider
  * @returns {number} actual number of points, this can be lower because input polygon has too few points
  */

package/src/core/geom/2d/hash-grid/SpatialHashGrid.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SpatialHashGrid.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/2d/hash-grid/SpatialHashGrid.js"],"names":[],"mappings":"AAMA,kCAAuC;AAuCvC,kCAAmC;AACnC,kCAAmC;AACnC,kCAAmC;AACnC,kCAAmC;AAEnC;IAuCI,8DAYC;IAxCD,qBAEC;IAED,qBAEC;IAED,mCAEC;IAED;;;OAGG;IACH,sCAEC;IAED,oBAEC;IAED,4BAEC;IAsBD,2BAIC;IAED,0DAKC;IAED,4CAKC;IAED;;;;;;;OAOG;IACH,sCANW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAYhB;IAED;;;OAGG;IACH,yBAFW,MAAM,QAIhB;IAED;;;OAGG;IACH,wBAFW,MAAM,QA8BhB;IAED;;;;OAIG;IACH,uBAHW,MAAM,GACL,MAAM,CAKjB;IAED;;;;OAIG;IACH,mCAHW,MAAM,GACL,MAAM,CAMjB;IAED;;;;OAIG;IACH,gCAHW,MAAM,GACL,MAAM,CAMjB;IAED;;;;;OAKG;IACH,gCAJW,MAAM,KACN,MAAM,GACL,MAAM,CAOjB;IAED;;;;;OAKG;IACH,0BAJW,MAAM,KACN,MAAM,GACJ,MAAM,CAgBlB;IAED;;;;;OAKG;IACH,sBAJW,MAAM,UACN,MAAM,GACL,OAAO,CAclB;IA0FD;;;OAGG;IACH,wBAFW,MAAM,QA+BhB;;CACJ;kCA7YiC,sDAAsD"}
+{"version":3,"file":"SpatialHashGrid.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/2d/hash-grid/SpatialHashGrid.js"],"names":[],"mappings":"AAMA,kCAAuC;AAuCvC,kCAAmC;AACnC,kCAAmC;AACnC,kCAAmC;AACnC,kCAAmC;AAEnC;IAuCI,8DAYC;IAxCD,qBAEC;IAED,qBAEC;IAED,mCAEC;IAED;;;OAGG;IACH,sCAEC;IAED,oBAEC;IAED,4BAEC;IAsBD,2BAIC;IAED,0DAKC;IAED,4CAKC;IAED;;;;;;;OAOG;IACH,sCANW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAYhB;IAED;;;OAGG;IACH,yBAFW,MAAM,QAIhB;IAED;;;OAGG;IACH,wBAFW,MAAM,QAwChB;IAED;;;;OAIG;IACH,uBAHW,MAAM,GACL,MAAM,CAKjB;IAED;;;;OAIG;IACH,mCAHW,MAAM,GACL,MAAM,CAMjB;IAED;;;;OAIG;IACH,gCAHW,MAAM,GACL,MAAM,CAMjB;IAED;;;;;OAKG;IACH,gCAJW,MAAM,KACN,MAAM,GACL,MAAM,CAOjB;IAED;;;;;OAKG;IACH,0BAJW,MAAM,KACN,MAAM,GACJ,MAAM,CAgBlB;IAED;;;;;OAKG;IACH,sBAJW,MAAM,UACN,MAAM,GACL,OAAO,CAclB;IA0FD;;;OAGG;IACH,wBAFW,MAAM,QAsChB;;CACJ;kCA9ZiC,sDAAsD"}

package/src/core/geom/2d/hash-grid/SpatialHashGrid.js

@@ -175,12 +175,22 @@ export class SpatialHashGrid {
         const x1 = float32[address + COLUMN_ELEMENT_X1];
         const y1 = float32[address + COLUMN_ELEMENT_Y1];
 
-        // convert to grid coordinates
-        const grid_x0 = Math.floor(x0 * this.#scale_inverse);
-        const grid_y0 = Math.floor(y0 * this.#scale_inverse);
-
-        const grid_x1 = Math.floor(x1 * this.#scale_inverse);
-        const grid_y1 = Math.floor(y1 * this.#scale_inverse);
+        /*
+         Convert to grid coordinates, clamped — the way world_position_to_cell_index does it a few
+         methods down. This used to floor without clamping, and cell_position_to_index is guarded
+         only by an assert the consumer strips, so an element that merely poked over the edge was
+         linked into the wrong cell: on a 16x16 grid of 32-unit cells, an element at (500,0)-(540,30)
+         gives grid_x1 = 16 and index 16, which is cell (0, 1) on the far left of the NEXT row, and a
+         query of that cell returned it. Past the bottom edge the index leaves the array entirely,
+         `grid_data[index]` reads undefined, and that is written into the node as 0 — making node 0
+         the phantom tail of the chain. An element overlapping the boundary is the case a spatial
+         grid exists to handle.
+        */
+        const grid_x0 = clamp(Math.floor(x0 * this.#scale_inverse), 0, this.#size_x - 1);
+        const grid_y0 = clamp(Math.floor(y0 * this.#scale_inverse), 0, this.#size_y - 1);
+
+        const grid_x1 = clamp(Math.floor(x1 * this.#scale_inverse), 0, this.#size_x - 1);
+        const grid_y1 = clamp(Math.floor(y1 * this.#scale_inverse), 0, this.#size_y - 1);
 
         for (let y = grid_y0; y <= grid_y1; y++) {
             for (let x = grid_x0; x <= grid_x1; x++) {
@@ -392,10 +402,17 @@ export class SpatialHashGrid {
             // cut this node from CELL list
             this.#grid_cell_remove_node(grid_index, node);
 
+            // and give the record back - `element_insert` takes one node per overlapping cell, and
+            // removing then re-inserting is the only supported way to move an element, so a node
+            // that is merely unlinked leaks on the normal path
+            node_pool.release(node);
 
             // advance onto next
             node = next;
         }
 
+        // the chain is gone; leaving the head pointing into it would hand a released node to the
+        // next walk of this element
+        element_pool.data_uint32[address + COLUMN_ELEMENT_NODE_FIRST] = NULL_POINTER;
     }
 }

package/src/core/geom/2d/line/ray2_ray2_compute_intersection_array_2d.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ray2_ray2_compute_intersection_array_2d.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/2d/line/ray2_ray2_compute_intersection_array_2d.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,6DAZW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,cAClC,MAAM,cACN,MAAM,cACN,MAAM,iBACN,MAAM,iBACN,MAAM,cACN,MAAM,cACN,MAAM,iBACN,MAAM,iBACN,MAAM,GACJ,OAAO,CAoCnB"}
+{"version":3,"file":"ray2_ray2_compute_intersection_array_2d.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/2d/line/ray2_ray2_compute_intersection_array_2d.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,6DAZW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,cAClC,MAAM,cACN,MAAM,cACN,MAAM,iBACN,MAAM,iBACN,MAAM,cACN,MAAM,cACN,MAAM,iBACN,MAAM,iBACN,MAAM,GACJ,OAAO,CAgDnB"}

package/src/core/geom/2d/line/ray2_ray2_compute_intersection_array_2d.js

@@ -30,8 +30,20 @@ export function ray2_ray2_compute_intersection_array_2d(
 
     const t = (direction_b_x * oab_y - direction_b_y * oab_x) / denominator;
 
-    if (t < 0.5) // Intersects on the wrong side
+    if (t < 0) {
+        /*
+         The wrong side of a ray is behind its origin, which is t < 0.
+
+         The threshold used to be 0.5, an unexplained magic number that also threw away every
+         legitimate forward intersection in [0, 0.5). The parameterisation is deliberately
+         non-unit — the direction comes from the line length, see the note above — so t is a
+         fraction of the source edge, and 0.5 meant "the intersection lands in the first half of
+         it". Both hull consumers pass an edge vector, so the rejected band was the near half of
+         every edge, and a caller of something named ray2_ray2_* got a wrong `false` with `out`
+         left holding whatever it held before.
+        */
         return false;
+    }
 
     const point_x = origin_a_x + t * direction_a_x;
     const point_y = origin_a_y + t * direction_a_y;

package/src/core/geom/3d/aabb/aabb3_raycast_hit_point.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"aabb3_raycast_hit_point.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/aabb/aabb3_raycast_hit_point.js"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,gDArBW,MAAM,EAAE,GAAC,UAAU,MAAM,CAAC,GAAC,YAAY,iBACvC,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,YACN,MAAM,YACN,MAAM,YACN,MAAM,eACN,MAAM,eACN,MAAM,eACN,MAAM,GACJ,OAAO,CAqFnB"}
+{"version":3,"file":"aabb3_raycast_hit_point.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/aabb/aabb3_raycast_hit_point.js"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,gDArBW,MAAM,EAAE,GAAC,UAAU,MAAM,CAAC,GAAC,YAAY,iBACvC,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,YACN,MAAM,YACN,MAAM,YACN,MAAM,eACN,MAAM,eACN,MAAM,eACN,MAAM,GACJ,OAAO,CA0GnB"}

package/src/core/geom/3d/aabb/aabb3_raycast_hit_point.js

@@ -49,18 +49,33 @@ export function aabb3_raycast_hit_point(
     const t1_z = (z0 - origin_z) * dir_inv_z;
     const t2_z = (z1 - origin_z) * dir_inv_z;
 
-    let tMax = max2(t1_x, t2_x);
-    tMax = min2(tMax, max2(t1_y, t2_y));
-    tMax = min2(tMax, max2(t1_z, t2_z));
+    // A NaN slab coordinate (`0 · ±Infinity`) flags an axis-aligned ray whose origin lies exactly on
+    // one of this slab's faces: it is parallel to the slab and, because the closed box owns its
+    // faces, stays inside it for every t. Such an axis contributes the fully-open interval
+    // [-Infinity, +Infinity]. `min2`/`max2` are `a < b ? … : …`, which swallow a NaN asymmetrically
+    // rather than propagating it, so letting the raw value through used to leave both bounds at
+    // Infinity, pass the miss test, and report a hit at `origin + direction * Infinity`.
+    // Same treatment as `aabb3_ray_segment_entry_distance`.
+    const x_parallel_on_face = t1_x !== t1_x || t2_x !== t2_x;
+    const y_parallel_on_face = t1_y !== t1_y || t2_y !== t2_y;
+    const z_parallel_on_face = t1_z !== t1_z || t2_z !== t2_z;
+
+    const t_min_x = x_parallel_on_face ? -Infinity : min2(t1_x, t2_x);
+    const t_min_y = y_parallel_on_face ? -Infinity : min2(t1_y, t2_y);
+    const t_min_z = z_parallel_on_face ? -Infinity : min2(t1_z, t2_z);
+
+    const t_max_x = x_parallel_on_face ? Infinity : max2(t1_x, t2_x);
+    const t_max_y = y_parallel_on_face ? Infinity : max2(t1_y, t2_y);
+    const t_max_z = z_parallel_on_face ? Infinity : max2(t1_z, t2_z);
+
+    const tMax = min2(min2(t_max_x, t_max_y), t_max_z);
 
     if (tMax < 0) {
         // if tMax < 0, AABB is behind the ray origin in the opposite direction to the ray's
         return false;
     }
 
-    let tMin = min2(t1_x, t2_x);
-    tMin = max2(tMin, min2(t1_y, t2_y));
-    tMin = max2(tMin, min2(t1_z, t2_z));
+    const tMin = max2(max2(t_min_x, t_min_y), t_min_z);
 
     if (tMin > tMax) {
         // if tMin > tMax, ray does not intersect the AABB
@@ -68,42 +83,48 @@ export function aabb3_raycast_hit_point(
     }
 
     // ray hit detected, figure out offset along the ray from origin to hit
-    const ray_offset = tMin < 0 ? tMax : tMin;
+    const entering = tMin >= 0;
+
+    const ray_offset = entering ? tMin : tMax;
+
+    if (ray_offset !== ray_offset || ray_offset === Infinity || ray_offset === -Infinity) {
+        // a ray with no usable direction - every slab degenerate - has no hit point to report
+        return false;
+    }
 
     const hit_x = origin_x + direction_x * ray_offset;
     const hit_y = origin_y + direction_y * ray_offset;
     const hit_z = origin_z + direction_z * ray_offset;
 
-    // figure out normal
-    const center_x = (x0 + x1) * 0.5;
-    const center_y = (y0 + y1) * 0.5;
-    const center_z = (z0 + z1) * 0.5;
-
-    const p_x = hit_x - center_x;
-    const p_y = hit_y - center_y;
-    const p_z = hit_z - center_z;
-
-    const d_x = (x0 - x1) * 0.5;
-    const d_y = (y0 - y1) * 0.5;
-    const d_z = (z0 - z1) * 0.5;
-
-    // bias is necessary to deal with rounding errors
-    const bias = 1.000001;
-
-    const normal_x = (p_x / Math.abs(d_x) * bias) | 0;
-    const normal_y = (p_y / Math.abs(d_y) * bias) | 0;
-    const normal_z = (p_z / Math.abs(d_z) * bias) | 0;
-
-    // normalize surface normal vector
-    const normal_inv_length = 1 / v3_length(normal_x, normal_y, normal_z);
+    // The normal is the outward normal of whichever slab supplied the chosen t, which is exact.
+    // Quantising `(hit - centre) / half_extent` instead is `0/0` on any axis the box is flat on,
+    // and the normalize that follows turns the whole normal into NaN.
+    //
+    // On entry the face met is the one the ray approaches, so its outward normal opposes the
+    // direction; on the way out of a box the origin is already inside, it faces along it.
+    const facing = entering ? -1 : 1;
+
+    let normal_x = 0;
+    let normal_y = 0;
+    let normal_z = 0;
+
+    const chosen = entering ? tMin : tMax;
+
+    if (chosen === (entering ? t_min_x : t_max_x)) {
+        normal_x = direction_x < 0 ? -facing : facing;
+    } else if (chosen === (entering ? t_min_y : t_max_y)) {
+        normal_y = direction_y < 0 ? -facing : facing;
+    } else {
+        normal_z = direction_z < 0 ? -facing : facing;
+    }
 
     result[result_offset] = hit_x;
     result[result_offset + 1] = hit_y;
     result[result_offset + 2] = hit_z;
 
-    result[result_offset + 3] = normal_x * normal_inv_length;
-    result[result_offset + 4] = normal_y * normal_inv_length;
-    result[result_offset + 5] = normal_z * normal_inv_length;
+    result[result_offset + 3] = normal_x;
+    result[result_offset + 4] = normal_y;
+    result[result_offset + 5] = normal_z;
 
     return true;
 }

package/src/core/geom/3d/atlas/segment/atlas_chart_growth_cost.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Cost of absorbing one growth node into the chart being grown, from the three terms the segmenters
+ * measure.
+ *
+ * `atlas_segment_charts` grows a chart one triangle at a time and `atlas_segment_charts_atomic` grows it
+ * one coplanar region at a time; they are two nodes over one cost function, and one option set
+ * (`ATLAS_SEGMENT_DEFAULTS`) weights it. This line used to be written out in both, which is the one
+ * divergence that would matter most: `atlas_compute_charts` picks between the two on
+ * `options.segment.atomic` and the bench's A/B runner compares their outputs, so the two weighting a
+ * chart differently would make that comparison meaningless without failing anything.
+ *
+ * @param {object} opt the resolved option set; reads `normalDeviationWeight`, `normalSeamWeight` and
+ * `roundnessWeight`
+ * @param {number} normal_deviation `min(1 - dot(chart_normal, node_normal), 1)`
+ * @param {number} normal_seam seam length over shared length along the boundary being absorbed, or 0
+ * @param {number} roundness the roundness delta from {@link atlas_chart_roundness_delta}
+ * @returns {number}
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function atlas_chart_growth_cost(opt: object, normal_deviation: number, normal_seam: number, roundness: number): number;
+/**
+ * Normalise a chart's running area-weighted normal accumulator into `out`.
+ *
+ * A chart with no accumulated area — or one whose faces' area-weighted normals happen to cancel — divides
+ * by one instead, leaving whatever direction the accumulator held. That is deliberate: the alternative is
+ * a NaN normal, which makes every subsequent deviation test fail the reject and grows the chart over
+ * everything.
+ *
+ * @param {Float32Array|number[]} out length >= 3
+ * @param {number} accumulated_x
+ * @param {number} accumulated_y
+ * @param {number} accumulated_z
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function atlas_chart_unit_normal(out: Float32Array | number[], accumulated_x: number, accumulated_y: number, accumulated_z: number): void;
+//# sourceMappingURL=atlas_chart_growth_cost.d.ts.map

package/src/core/geom/3d/atlas/segment/atlas_chart_growth_cost.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"atlas_chart_growth_cost.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/geom/3d/atlas/segment/atlas_chart_growth_cost.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,6CAVW,MAAM,oBAEN,MAAM,eACN,MAAM,aACN,MAAM,GACJ,MAAM,CASlB;AAED;;;;;;;;;;;;;;;GAeG;AACH,6CARW,YAAY,GAAC,MAAM,EAAE,iBACrB,MAAM,iBACN,MAAM,iBACN,MAAM,QAehB"}

package/src/core/geom/3d/atlas/segment/atlas_chart_growth_cost.js

@@ -0,0 +1,54 @@
+/**
+ * Cost of absorbing one growth node into the chart being grown, from the three terms the segmenters
+ * measure.
+ *
+ * `atlas_segment_charts` grows a chart one triangle at a time and `atlas_segment_charts_atomic` grows it
+ * one coplanar region at a time; they are two nodes over one cost function, and one option set
+ * (`ATLAS_SEGMENT_DEFAULTS`) weights it. This line used to be written out in both, which is the one
+ * divergence that would matter most: `atlas_compute_charts` picks between the two on
+ * `options.segment.atomic` and the bench's A/B runner compares their outputs, so the two weighting a
+ * chart differently would make that comparison meaningless without failing anything.
+ *
+ * @param {object} opt the resolved option set; reads `normalDeviationWeight`, `normalSeamWeight` and
+ * `roundnessWeight`
+ * @param {number} normal_deviation `min(1 - dot(chart_normal, node_normal), 1)`
+ * @param {number} normal_seam seam length over shared length along the boundary being absorbed, or 0
+ * @param {number} roundness the roundness delta from {@link atlas_chart_roundness_delta}
+ * @returns {number}
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function atlas_chart_growth_cost(opt, normal_deviation, normal_seam, roundness) {
+    return opt.normalDeviationWeight * normal_deviation
+        + opt.normalSeamWeight * normal_seam
+        + opt.roundnessWeight * roundness;
+}
+
+/**
+ * Normalise a chart's running area-weighted normal accumulator into `out`.
+ *
+ * A chart with no accumulated area — or one whose faces' area-weighted normals happen to cancel — divides
+ * by one instead, leaving whatever direction the accumulator held. That is deliberate: the alternative is
+ * a NaN normal, which makes every subsequent deviation test fail the reject and grows the chart over
+ * everything.
+ *
+ * @param {Float32Array|number[]} out length >= 3
+ * @param {number} accumulated_x
+ * @param {number} accumulated_y
+ * @param {number} accumulated_z
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function atlas_chart_unit_normal(out, accumulated_x, accumulated_y, accumulated_z) {
+    const length = Math.sqrt(
+        accumulated_x * accumulated_x
+        + accumulated_y * accumulated_y
+        + accumulated_z * accumulated_z
+    ) || 1;
+
+    out[0] = accumulated_x / length;
+    out[1] = accumulated_y / length;
+    out[2] = accumulated_z / length;
+}

package/src/core/geom/3d/atlas/segment/atlas_segment_charts.d.ts

@@ -17,9 +17,27 @@
  * deterministic, and there is no wall-clock exit — the labelling is
  * reproducible.
  *
- * Note: segmentation here is face-granular. xatlas grows whole coplanar regions
- * atomically; that is a quality/perf refinement layered on the same cost and is
- * a deferred follow-up.
+ * ## Face-granular, and the region-atomic sibling
+ *
+ * Segmentation here is face-granular. xatlas grows whole coplanar regions atomically, and
+ * {@link atlas_segment_charts_atomic} does that — it exists, and `atlas_compute_charts` selects it by
+ * default (`options.segment?.atomic ?? true`). This docblock used to call it a deferred follow-up.
+ *
+ * The two run the same greedy loop over different nodes, and that loop is deliberately written out
+ * twice rather than parameterised over a node accessor: doing so would put several closure calls into
+ * each candidate evaluation on a path that evaluates once per triangle, and being cheaper per node
+ * than this one is the whole reason the atomic variant exists.
+ *
+ * What is shared is everything a change to the algorithm would have to land in — {@link
+ * ATLAS_SEGMENT_DEFAULTS}, {@link NORMAL_DEVIATION_REJECT}, {@link REJECT} and {@link STALE_EPSILON}
+ * (declared here, imported there), {@link atlas_chart_roundness_delta},
+ * {@link atlas_chart_unit_normal}, and {@link atlas_chart_growth_cost}, which is the one that matters
+ * most: the bench's A/B runner compares the two segmenters' outputs, and two different weightings
+ * would make that comparison meaningless without failing anything.
+ *
+ * `atlas_segmenters_agree.spec` closes the rest. On a mesh where no two adjacent faces are coplanar
+ * every region is a single triangle, the two node sets coincide, and the two must produce the same
+ * charts — so a divergence in either loop shape fails there rather than in a silent A/B.
  *
  * @param {BinaryTopology} mesh face normals must be populated
  * @param {Float32Array} face_areas from atlas_build_face_areas

package/src/core/geom/3d/atlas/segment/atlas_segment_charts.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"atlas_segment_charts.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/geom/3d/atlas/segment/atlas_segment_charts.js"],"names":[],"mappings":"AAwCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,uEAPW,YAAY,gBACZ,YAAY,kBACZ,YAAY,YACZ,MAAM,GACJ;IAAC,UAAU,EAAE,UAAU,CAAC;IAAC,WAAW,EAAE,MAAM,CAAA;CAAC,CA0MzD;AAzQD;;;;GAIG;AACH,qBAFU,MAAM,CAEe;AAE/B;;;;;GAKG;AACH,sCAFU,MAAM,CAE6B;AAE7C;;;;GAIG;AACH,4BAFU,MAAM,CAEkB"}
+{"version":3,"file":"atlas_segment_charts.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/geom/3d/atlas/segment/atlas_segment_charts.js"],"names":[],"mappings":"AAyCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AACH,uEAPW,YAAY,gBACZ,YAAY,kBACZ,YAAY,YACZ,MAAM,GACJ;IAAC,UAAU,EAAE,UAAU,CAAC;IAAC,WAAW,EAAE,MAAM,CAAA;CAAC,CAgMzD;AAjRD;;;;GAIG;AACH,qBAFU,MAAM,CAEe;AAE/B;;;;;GAKG;AACH,sCAFU,MAAM,CAE6B;AAE7C;;;;GAIG;AACH,4BAFU,MAAM,CAEkB"}

package/src/core/geom/3d/atlas/segment/atlas_segment_charts.js

@@ -1,3 +1,4 @@
+import { atlas_chart_growth_cost, atlas_chart_unit_normal } from "./atlas_chart_growth_cost.js";
 import { atlas_chart_roundness_delta } from "./atlas_chart_roundness_delta.js";
 import { IndexedFloatMinHeap } from "../../../../collection/heap/IndexedFloatMinHeap.js";
 import { v3_dot } from "../../../vec3/v3_dot.js";
@@ -57,9 +58,27 @@ export const ATLAS_SEGMENT_DEFAULTS = {
  * deterministic, and there is no wall-clock exit — the labelling is
  * reproducible.
  *
- * Note: segmentation here is face-granular. xatlas grows whole coplanar regions
- * atomically; that is a quality/perf refinement layered on the same cost and is
- * a deferred follow-up.
+ * ## Face-granular, and the region-atomic sibling
+ *
+ * Segmentation here is face-granular. xatlas grows whole coplanar regions atomically, and
+ * {@link atlas_segment_charts_atomic} does that — it exists, and `atlas_compute_charts` selects it by
+ * default (`options.segment?.atomic ?? true`). This docblock used to call it a deferred follow-up.
+ *
+ * The two run the same greedy loop over different nodes, and that loop is deliberately written out
+ * twice rather than parameterised over a node accessor: doing so would put several closure calls into
+ * each candidate evaluation on a path that evaluates once per triangle, and being cheaper per node
+ * than this one is the whole reason the atomic variant exists.
+ *
+ * What is shared is everything a change to the algorithm would have to land in — {@link
+ * ATLAS_SEGMENT_DEFAULTS}, {@link NORMAL_DEVIATION_REJECT}, {@link REJECT} and {@link STALE_EPSILON}
+ * (declared here, imported there), {@link atlas_chart_roundness_delta},
+ * {@link atlas_chart_unit_normal}, and {@link atlas_chart_growth_cost}, which is the one that matters
+ * most: the bench's A/B runner compares the two segmenters' outputs, and two different weightings
+ * would make that comparison meaningless without failing anything.
+ *
+ * `atlas_segmenters_agree.spec` closes the rest. On a mesh where no two adjacent faces are coplanar
+ * every region is a single triangle, the two node sets coincide, and the two must produce the same
+ * charts — so a divergence in either loop shape fails there rather than in a silent A/B.
  *
  * @param {BinaryTopology} mesh face normals must be populated
  * @param {Float32Array} face_areas from atlas_build_face_areas
@@ -92,16 +111,6 @@ export function atlas_segment_charts(mesh, face_areas, edge_lengths, edge_dihedr
     let out_area = 0;
     let out_boundary = 0;
 
-    /**
-     * Normalize the chart's running area-weighted normal accumulator into `cn`.
-     */
-    function chart_unit_normal() {
-        const len = Math.sqrt(accum_x * accum_x + accum_y * accum_y + accum_z * accum_z) || 1;
-        cn[0] = accum_x / len;
-        cn[1] = accum_y / len;
-        cn[2] = accum_z / len;
-    }
-
     /**
      * Sum of edge lengths around face f (its perimeter).
      * @param {number} f face id
@@ -126,7 +135,7 @@ export function atlas_segment_charts(mesh, face_areas, edge_lengths, edge_dihedr
      */
     function evaluate(g) {
         mesh.face_read_normal(fn, 0, g);
-        chart_unit_normal();
+        atlas_chart_unit_normal(cn, accum_x, accum_y, accum_z);
 
         const dot = v3_dot(cn[0], cn[1], cn[2], fn[0], fn[1], fn[2]);
         const N = Math.min(1 - dot, 1);
@@ -176,7 +185,7 @@ export function atlas_segment_charts(mesh, face_areas, edge_lengths, edge_dihedr
         out_area = new_area;
         out_boundary = new_boundary;
 
-        return opt.normalDeviationWeight * N + opt.normalSeamWeight * NS + opt.roundnessWeight * R;
+        return atlas_chart_growth_cost(opt, N, NS, R);
     }
 
     /**

package/src/core/geom/3d/atlas/segment/atlas_segment_charts_atomic.d.ts

@@ -6,9 +6,12 @@
  * This keeps coplanar faces together (no seam through a flat surface) and is
  * far cheaper on flat-heavy meshes (the heap holds regions, not triangles).
  *
- * Cost = `normalDeviationWeight·N + normalSeamWeight·NS + roundnessWeight·R`,
- * with the same 73-degree hard reject and optional area/boundary caps. The
- * candidate queue uses the same lazy re-evaluation. Deterministic.
+ * Cost is {@link atlas_chart_growth_cost}, the same function {@link atlas_segment_charts} weights its
+ * candidates with, and the same 73-degree hard reject and optional area/boundary caps. The candidate
+ * queue uses the same lazy re-evaluation. Deterministic.
+ *
+ * The growth loop is written out here rather than shared with `atlas_segment_charts` — see that
+ * function's docblock for why, and for what *is* shared.
  *
  * @param {RegionGraph} region_graph from atlas_build_region_graph
  * @param {Uint32Array} region_of_face face -> region id (NULL_POINTER if unallocated)

package/src/core/geom/3d/atlas/segment/atlas_segment_charts_atomic.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"atlas_segment_charts_atomic.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/geom/3d/atlas/segment/atlas_segment_charts_atomic.js"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;;;GAgBG;AACH,uFAJW,WAAW,YACX,MAAM,GACJ;IAAC,UAAU,EAAE,UAAU,CAAC;IAAC,WAAW,EAAE,MAAM,CAAA;CAAC,CAwKzD"}
+{"version":3,"file":"atlas_segment_charts_atomic.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/geom/3d/atlas/segment/atlas_segment_charts_atomic.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,uFAJW,WAAW,YACX,MAAM,GACJ;IAAC,UAAU,EAAE,UAAU,CAAC;IAAC,WAAW,EAAE,MAAM,CAAA;CAAC,CA8JzD"}

package/src/core/geom/3d/atlas/segment/atlas_segment_charts_atomic.js

@@ -1,6 +1,7 @@
 import { IndexedFloatMinHeap } from "../../../../collection/heap/IndexedFloatMinHeap.js";
 import { NULL_POINTER } from "../../topology/struct/binary/BinaryTopology.js";
 import { ATLAS_SEGMENT_DEFAULTS, NORMAL_DEVIATION_REJECT, REJECT, STALE_EPSILON } from "./atlas_segment_charts.js";
+import { atlas_chart_growth_cost, atlas_chart_unit_normal } from "./atlas_chart_growth_cost.js";
 import { atlas_chart_roundness_delta } from "./atlas_chart_roundness_delta.js";
 
 
@@ -13,9 +14,12 @@ import { atlas_chart_roundness_delta } from "./atlas_chart_roundness_delta.js";
  * This keeps coplanar faces together (no seam through a flat surface) and is
  * far cheaper on flat-heavy meshes (the heap holds regions, not triangles).
  *
- * Cost = `normalDeviationWeight·N + normalSeamWeight·NS + roundnessWeight·R`,
- * with the same 73-degree hard reject and optional area/boundary caps. The
- * candidate queue uses the same lazy re-evaluation. Deterministic.
+ * Cost is {@link atlas_chart_growth_cost}, the same function {@link atlas_segment_charts} weights its
+ * candidates with, and the same 73-degree hard reject and optional area/boundary caps. The candidate
+ * queue uses the same lazy re-evaluation. Deterministic.
+ *
+ * The growth loop is written out here rather than shared with `atlas_segment_charts` — see that
+ * function's docblock for why, and for what *is* shared.
  *
  * @param {RegionGraph} region_graph from atlas_build_region_graph
  * @param {Uint32Array} region_of_face face -> region id (NULL_POINTER if unallocated)
@@ -40,16 +44,6 @@ export function atlas_segment_charts_atomic(region_graph, region_of_face, option
     let out_area = 0;
     let out_boundary = 0;
 
-    /**
-     * Normalize the chart's running area-weighted normal accumulator into `cn`.
-     */
-    function chart_unit_normal() {
-        const len = Math.sqrt(accum_x * accum_x + accum_y * accum_y + accum_z * accum_z) || 1;
-        cn[0] = accum_x / len;
-        cn[1] = accum_y / len;
-        cn[2] = accum_z / len;
-    }
-
     /**
      * Cost of adding region g to the current chart, or REJECT. Side effect: sets
      * out_area / out_boundary for the caller to commit.
@@ -62,7 +56,7 @@ export function atlas_segment_charts_atomic(region_graph, region_of_face, option
         const gz = rg.region_normal[g * 3 + 2];
         const glen = Math.sqrt(gx * gx + gy * gy + gz * gz) || 1;
 
-        chart_unit_normal();
+        atlas_chart_unit_normal(cn, accum_x, accum_y, accum_z);
         const dot = (cn[0] * gx + cn[1] * gy + cn[2] * gz) / glen;
         const N = Math.min(1 - dot, 1);
         if (N >= NORMAL_DEVIATION_REJECT) {
@@ -97,7 +91,7 @@ export function atlas_segment_charts_atomic(region_graph, region_of_face, option
         out_area = new_area;
         out_boundary = new_boundary;
 
-        return opt.normalDeviationWeight * N + opt.normalSeamWeight * NS + opt.roundnessWeight * R;
+        return atlas_chart_growth_cost(opt, N, NS, R);
     }
 
     /**

package/src/core/geom/3d/cone/cone_compute_plane_side.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cone_compute_plane_side.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/cone/cone_compute_plane_side.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;;GAgBG;AACH,wDAdW,MAAM,kBACN,MAAM,kBACN,MAAM,kBACN,MAAM,WACN,MAAM,WACN,MAAM,WACN,MAAM,cACN,MAAM,cACN,MAAM,cACN,MAAM,SACN,MAAM,UACN,MAAM,GACJ,MAAM,CAgElB"}
+{"version":3,"file":"cone_compute_plane_side.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/cone/cone_compute_plane_side.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;;GAgBG;AACH,wDAdW,MAAM,kBACN,MAAM,kBACN,MAAM,kBACN,MAAM,WACN,MAAM,WACN,MAAM,WACN,MAAM,cACN,MAAM,cACN,MAAM,cACN,MAAM,SACN,MAAM,UACN,MAAM,GACJ,MAAM,CA4ElB"}