@woosh/meep-engine 2.169.0 → 2.169.2

package/src/core/geom/3d/aabb/AABB3.d.ts

@@ -336,10 +336,10 @@ export class AABB3 {
     threeContainsBox(box: THREE.Box): boolean;
     /**
      *
-     * @param {function(x:number, y:number, z:number)} callback
+     * @param {(x: number, y: number, z: number) => void} callback
      * @param {*} [thisArg]
      */
-    traverseCorners(callback: any, thisArg?: any): void;
+    traverseCorners(callback: (x: number, y: number, z: number) => void, thisArg?: any): void;
     /**
      *
      * @param {number[]|Float64Array|Float32Array} result

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

@@ -1 +1 @@
-{"version":3,"file":"AABB3.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/aabb/AABB3.js"],"names":[],"mappings":"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"}
+{"version":3,"file":"AABB3.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/aabb/AABB3.js"],"names":[],"mappings":"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"}

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

@@ -731,7 +731,7 @@ export class AABB3 {
 
     /**
      *
-     * @param {function(x:number, y:number, z:number)} callback
+     * @param {(x: number, y: number, z: number) => void} callback
      * @param {*} [thisArg]
      */
     traverseCorners(callback, thisArg) {

package/src/core/geom/3d/aabb/aabb3_intersects_ray_segment.d.ts

@@ -3,14 +3,13 @@
  * BROADPHASE use: it must never report a false miss for a segment that grazes a face, since callers treat
  * a `false` as "no candidate here" and skip the exact geometry test entirely.
  *
- * Robust at the degenerate "axis-aligned ray with the origin exactly on a face" boundary. When a direction
- * component is `0` its reciprocal is `±Infinity`, so the slab coordinate of the face the origin sits on is
- * `0 · ±Infinity = NaN`. A NaN can ONLY arise that way (it needs a `(face − origin)` term of exactly `0`),
- * and it always means the ray runs parallel to that slab with the origin on one of its planes — i.e. inside
- * the closed slab for every `t`. That axis therefore contributes the fully-open interval `[-Infinity,
- * +Infinity]`, imposing no constraint. Letting the NaN flow through `min2`/`max2` instead collapses the
- * final test to `NaN <= … = false` and drops a box the ray genuinely crosses (a NaN-ignoring min/max alone
- * is NOT enough — it yields `[-Infinity, -Infinity]` / `[+Infinity, +Infinity]`, still a spurious miss).
+ * This is the boolean face of {@link aabb3_ray_segment_entry_distance} and is defined as "that query did
+ * not return its miss sentinel", so the two cannot disagree. The slab arithmetic — including the NaN
+ * handling for an axis-aligned ray whose origin sits exactly on a face — lives there and is documented
+ * there; keeping a second copy here is how the two previously drifted apart.
+ *
+ * PRECONDITION: the direction is non-degenerate (at least one non-zero component). A zero direction makes
+ * every slab coordinate `±Infinity`, for which "entry distance" is not meaningful.
  *
  * @see Ray Tracing Gems II, Chapter 2 "RAY AXIS-ALIGNED BOUNDING BOX INTERSECTION"
  * @param {number} x0

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

@@ -1 +1 @@
-{"version":3,"file":"aabb3_intersects_ray_segment.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/aabb/aabb3_intersects_ray_segment.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,iDAhBW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,YACN,MAAM,YACN,MAAM,YACN,MAAM,mBACN,MAAM,mBACN,MAAM,mBACN,MAAM,gBACN,MAAM,gBACN,MAAM,GACJ,OAAO,CAmDnB"}
+{"version":3,"file":"aabb3_intersects_ray_segment.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/aabb/aabb3_intersects_ray_segment.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,iDAhBW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,YACN,MAAM,YACN,MAAM,YACN,MAAM,mBACN,MAAM,mBACN,MAAM,mBACN,MAAM,gBACN,MAAM,gBACN,MAAM,GACJ,OAAO,CAiBnB"}

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

@@ -1,19 +1,17 @@
-import { max2 } from "../../../math/max2.js";
-import { min2 } from "../../../math/min2.js";
+import { aabb3_ray_segment_entry_distance } from "./aabb3_ray_segment_entry_distance.js";
 
 /**
  * Conservative slab test of an axis-aligned ray SEGMENT against a closed AABB (faces included). Built for
  * BROADPHASE use: it must never report a false miss for a segment that grazes a face, since callers treat
  * a `false` as "no candidate here" and skip the exact geometry test entirely.
  *
- * Robust at the degenerate "axis-aligned ray with the origin exactly on a face" boundary. When a direction
- * component is `0` its reciprocal is `±Infinity`, so the slab coordinate of the face the origin sits on is
- * `0 · ±Infinity = NaN`. A NaN can ONLY arise that way (it needs a `(face − origin)` term of exactly `0`),
- * and it always means the ray runs parallel to that slab with the origin on one of its planes — i.e. inside
- * the closed slab for every `t`. That axis therefore contributes the fully-open interval `[-Infinity,
- * +Infinity]`, imposing no constraint. Letting the NaN flow through `min2`/`max2` instead collapses the
- * final test to `NaN <= … = false` and drops a box the ray genuinely crosses (a NaN-ignoring min/max alone
- * is NOT enough — it yields `[-Infinity, -Infinity]` / `[+Infinity, +Infinity]`, still a spurious miss).
+ * This is the boolean face of {@link aabb3_ray_segment_entry_distance} and is defined as "that query did
+ * not return its miss sentinel", so the two cannot disagree. The slab arithmetic — including the NaN
+ * handling for an axis-aligned ray whose origin sits exactly on a face — lives there and is documented
+ * there; keeping a second copy here is how the two previously drifted apart.
+ *
+ * PRECONDITION: the direction is non-degenerate (at least one non-zero component). A zero direction makes
+ * every slab coordinate `±Infinity`, for which "entry distance" is not meaningful.
  *
  * @see Ray Tracing Gems II, Chapter 2 "RAY AXIS-ALIGNED BOUNDING BOX INTERSECTION"
  * @param {number} x0
@@ -40,46 +38,12 @@ export function aabb3_intersects_ray_segment(
     min_distance, max_distance
 ) {
 
-    // move aabb into ray space
-    const _x0 = x0 - origin_x;
-    const _y0 = y0 - origin_y;
-    const _z0 = z0 - origin_z;
-
-    const _x1 = x1 - origin_x;
-    const _y1 = y1 - origin_y;
-    const _z1 = z1 - origin_z;
-
-
-    // Absolute distances to lower and upper box coordinates
-    const t_lower_x = _x0 * inv_direction_x;
-    const t_lower_y = _y0 * inv_direction_y;
-    const t_lower_z = _z0 * inv_direction_z;
-
-    const t_upper_x = _x1 * inv_direction_x;
-    const t_upper_y = _y1 * inv_direction_y;
-    const t_upper_z = _z1 * inv_direction_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]; see
-    // the function doc for why the raw NaN min/max would instead poison the test into a false miss.
-    const x_parallel_on_face = t_lower_x !== t_lower_x || t_upper_x !== t_upper_x;
-    const y_parallel_on_face = t_lower_y !== t_lower_y || t_upper_y !== t_upper_y;
-    const z_parallel_on_face = t_lower_z !== t_lower_z || t_upper_z !== t_upper_z;
-
-    // The four t-intervals (for x-/y-/z-slabs, and ray p(t))
-    const t_min_x = x_parallel_on_face ? -Infinity : min2(t_lower_x, t_upper_x);
-    const t_min_y = y_parallel_on_face ? -Infinity : min2(t_lower_y, t_upper_y);
-    const t_min_z = z_parallel_on_face ? -Infinity : min2(t_lower_z, t_upper_z);
-
-    const t_max_x = x_parallel_on_face ? Infinity : max2(t_lower_x, t_upper_x);
-    const t_max_y = y_parallel_on_face ? Infinity : max2(t_lower_y, t_upper_y);
-    const t_max_z = z_parallel_on_face ? Infinity : max2(t_lower_z, t_upper_z);
-
-    // Easy to remember: ``max of mins, and min of maxes''
-    const t_box_min = Math.max(t_min_x, t_min_y, t_min_z, min_distance);
-    const t_box_max = Math.min(t_max_x, t_max_y, t_max_z, max_distance);
-
-    return t_box_min <= t_box_max;
+    return aabb3_ray_segment_entry_distance(
+        x0, y0, z0,
+        x1, y1, z1,
+        origin_x, origin_y, origin_z,
+        inv_direction_x, inv_direction_y, inv_direction_z,
+        min_distance, max_distance
+    ) !== Infinity;
 }
 

package/src/core/geom/3d/atlas/param/atlas_chart_parameterize_bff.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"atlas_chart_parameterize_bff.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/geom/3d/atlas/param/atlas_chart_parameterize_bff.js"],"names":[],"mappings":"AAoDA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH;gBAJuB,MAAM;oBAAiB,MAAM;IACvC,OAAO,CA4LnB"}
+{"version":3,"file":"atlas_chart_parameterize_bff.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/geom/3d/atlas/param/atlas_chart_parameterize_bff.js"],"names":[],"mappings":"AAmDA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH;gBAJuB,MAAM;oBAAiB,MAAM;IACvC,OAAO,CA4LnB"}

package/src/core/geom/3d/atlas/param/atlas_chart_parameterize_bff.js

@@ -1,3 +1,4 @@
+import { tri3_flatten_isometric_indexed } from "../../triangle/tri3_flatten_isometric.js";
 import { cg_solve } from "../../../../math/linalg/cg/cg_solve.js";
 import { cg_solve_normal_equations } from "../../../../math/linalg/cg/cg_solve_normal_equations.js";
 import { SparseMatrixCSR } from "../../../../math/linalg/sparse/SparseMatrixCSR.js";
@@ -23,7 +24,16 @@ function clamped_cot(pos, o, p, q) {
     return c > COT_MAX ? COT_MAX : c;
 }
 
-/** Interior angle (radians) at vertex i0 in triangle (i0,i1,i2). */
+/**
+ * Interior angle (radians) at vertex i0 in triangle (i0,i1,i2).
+ *
+ * Deliberately NOT `v3_angle`, despite computing the same angle for well-formed triangles. The two
+ * disagree exactly where it matters here: `v3_angle` delegates to `v3_cos_angle`, which returns 0 for a
+ * zero-length edge, so `v3_angle` reports `acos(0) = PI/2`. This returns 0 radians instead, and does so
+ * for any edge under 1e-20 rather than only for exactly-zero ones. Curvature below is accumulated as
+ * `Omega = 2*PI - sum(theta)`, so a degenerate sliver contributing PI/2 instead of 0 would silently
+ * corrupt the curvature of the vertex it touches.
+ */
 function interior_angle(pos, i0, i1, i2) {
     const ux = pos[i1 * 3] - pos[i0 * 3], uy = pos[i1 * 3 + 1] - pos[i0 * 3 + 1], uz = pos[i1 * 3 + 2] - pos[i0 * 3 + 2];
     const vx = pos[i2 * 3] - pos[i0 * 3], vy = pos[i2 * 3 + 1] - pos[i0 * 3 + 1], vz = pos[i2 * 3 + 2] - pos[i0 * 3 + 2];
@@ -34,20 +44,9 @@ function interior_angle(pos, i0, i1, i2) {
     return Math.acos(Math.max(-1, Math.min(1, c)));
 }
 
-/** Flatten a triangle into an isometric local 2D frame (vertex 0 at origin,
- *  vertex 1 on +x): writes [x2, x3, y3] into `out`. (Same as LSCM.) */
+/** Flatten a triangle into an isometric local 2D frame; writes [len_ab, x_c, y_c] into `out`. */
 function project_triangle(pos, i0, i1, i2, out) {
-    const ax = pos[i0 * 3], ay = pos[i0 * 3 + 1], az = pos[i0 * 3 + 2];
-    const e1x = pos[i1 * 3] - ax, e1y = pos[i1 * 3 + 1] - ay, e1z = pos[i1 * 3 + 2] - az;
-    const len1 = Math.sqrt(e1x * e1x + e1y * e1y + e1z * e1z);
-    const inv1 = len1 > 0 ? 1 / len1 : 0;
-    const ux = e1x * inv1, uy = e1y * inv1, uz = e1z * inv1;
-    const e2x = pos[i2 * 3] - ax, e2y = pos[i2 * 3 + 1] - ay, e2z = pos[i2 * 3 + 2] - az;
-    const x3 = e2x * ux + e2y * uy + e2z * uz;
-    const px = e2x - x3 * ux, py = e2y - x3 * uy, pz = e2z - x3 * uz;
-    out[0] = len1;
-    out[1] = x3;
-    out[2] = Math.sqrt(px * px + py * py + pz * pz);
+    tri3_flatten_isometric_indexed(out, 0, pos, i0, i1, i2);
 }
 
 /**

package/src/core/geom/3d/atlas/param/atlas_chart_parameterize_lscm.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"atlas_chart_parameterize_lscm.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/geom/3d/atlas/param/atlas_chart_parameterize_lscm.js"],"names":[],"mappings":"AAmFA;;;;;;;;;;;;;;;;;GAiBG;AACH;gBAJuB,MAAM;oBAAiB,MAAM;IACvC,OAAO,CA6HnB"}
+{"version":3,"file":"atlas_chart_parameterize_lscm.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/geom/3d/atlas/param/atlas_chart_parameterize_lscm.js"],"names":[],"mappings":"AAoEA;;;;;;;;;;;;;;;;;GAiBG;AACH;gBAJuB,MAAM;oBAAiB,MAAM;IACvC,OAAO,CA6HnB"}

package/src/core/geom/3d/atlas/param/atlas_chart_parameterize_lscm.js

@@ -1,3 +1,4 @@
+import { tri3_flatten_isometric_indexed } from "../../triangle/tri3_flatten_isometric.js";
 import { cg_solve_normal_equations } from "../../../../math/linalg/cg/cg_solve_normal_equations.js";
 import { SparseMatrixCSR } from "../../../../math/linalg/sparse/SparseMatrixCSR.js";
 
@@ -62,23 +63,7 @@ function find_diameter_pins(chart) {
  * @returns {void}
  */
 function project_triangle(pos, i0, i1, i2, out) {
-    const ax = pos[i0 * 3], ay = pos[i0 * 3 + 1], az = pos[i0 * 3 + 2];
-    const bx = pos[i1 * 3], by = pos[i1 * 3 + 1], bz = pos[i1 * 3 + 2];
-    const cx = pos[i2 * 3], cy = pos[i2 * 3 + 1], cz = pos[i2 * 3 + 2];
-
-    const e1x = bx - ax, e1y = by - ay, e1z = bz - az;
-    const len1 = Math.sqrt(e1x * e1x + e1y * e1y + e1z * e1z);
-    const inv1 = len1 > 0 ? 1 / len1 : 0;
-    const ux = e1x * inv1, uy = e1y * inv1, uz = e1z * inv1;
-
-    const e2x = cx - ax, e2y = cy - ay, e2z = cz - az;
-    const x3 = e2x * ux + e2y * uy + e2z * uz;
-    const px = e2x - x3 * ux, py = e2y - x3 * uy, pz = e2z - x3 * uz;
-    const y3 = Math.sqrt(px * px + py * py + pz * pz);
-
-    out[0] = len1;
-    out[1] = x3;
-    out[2] = y3;
+    tri3_flatten_isometric_indexed(out, 0, pos, i0, i1, i2);
 }
 
 /**

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

@@ -0,0 +1,22 @@
+/**
+ * Roundness term `R` of the xatlas chart-growth cost: how much worse the chart's
+ * perimeter-to-area ratio gets by absorbing a candidate.
+ *
+ * `R = 1 - old_ratio / new_ratio` with `ratio = boundary^2 / area`. Positive when the candidate makes the
+ * chart less compact, so the greedy segmenter prefers round charts. Returns 0 for the seed step (no chart
+ * yet) and for degenerate zero-area / zero-boundary states, where the ratio is undefined.
+ *
+ * Shared by the face-granular {@link atlas_segment_charts} and the region-atomic
+ * {@link atlas_segment_charts_atomic}, which must agree on the cost function to produce comparable charts.
+ *
+ * @param {number} chart_area area of the chart before absorbing the candidate
+ * @param {number} chart_boundary boundary length before absorbing the candidate
+ * @param {number} new_area area after absorbing
+ * @param {number} new_boundary boundary length after absorbing
+ * @returns {number}
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function atlas_chart_roundness_delta(chart_area: number, chart_boundary: number, new_area: number, new_boundary: number): number;
+//# sourceMappingURL=atlas_chart_roundness_delta.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"atlas_chart_roundness_delta.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/geom/3d/atlas/segment/atlas_chart_roundness_delta.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wDATW,MAAM,kBACN,MAAM,YACN,MAAM,gBACN,MAAM,GACJ,MAAM,CAclB"}

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

@@ -0,0 +1,30 @@
+/**
+ * Roundness term `R` of the xatlas chart-growth cost: how much worse the chart's
+ * perimeter-to-area ratio gets by absorbing a candidate.
+ *
+ * `R = 1 - old_ratio / new_ratio` with `ratio = boundary^2 / area`. Positive when the candidate makes the
+ * chart less compact, so the greedy segmenter prefers round charts. Returns 0 for the seed step (no chart
+ * yet) and for degenerate zero-area / zero-boundary states, where the ratio is undefined.
+ *
+ * Shared by the face-granular {@link atlas_segment_charts} and the region-atomic
+ * {@link atlas_segment_charts_atomic}, which must agree on the cost function to produce comparable charts.
+ *
+ * @param {number} chart_area area of the chart before absorbing the candidate
+ * @param {number} chart_boundary boundary length before absorbing the candidate
+ * @param {number} new_area area after absorbing
+ * @param {number} new_boundary boundary length after absorbing
+ * @returns {number}
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function atlas_chart_roundness_delta(chart_area, chart_boundary, new_area, new_boundary) {
+    if (chart_area > 0 && chart_boundary > 0 && new_boundary > 0) {
+        const old_ratio = (chart_boundary * chart_boundary) / chart_area;
+        const new_ratio = (new_boundary * new_boundary) / new_area;
+
+        return 1 - old_ratio / new_ratio;
+    }
+
+    return 0;
+}

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

@@ -33,6 +33,25 @@ export function atlas_segment_charts(mesh: BinaryTopology, face_areas: Float32Ar
     face_chart: Int32Array;
     chart_count: number;
 };
+/**
+ * Cost returned for a face that must not join the chart (hard reject). Never
+ * inserted into the heap.
+ * @type {number}
+ */
+export const REJECT: number;
+/**
+ * Hard reject when the normal-deviation term reaches this — `1 - dot >= 0.707`
+ * is roughly a 73 degree fold away from the chart's running normal. Matches
+ * xatlas's `computeCost` hard cutoff.
+ * @type {number}
+ */
+export const NORMAL_DEVIATION_REJECT: number;
+/**
+ * A heap entry is considered stale (recomputed against a drifted chart normal)
+ * when its fresh cost differs from the stored cost by more than this.
+ * @type {number}
+ */
+export const STALE_EPSILON: number;
 export namespace ATLAS_SEGMENT_DEFAULTS {
     let maxCost: number;
     let normalDeviationWeight: number;

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":"AAuCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,uEAPW,YAAY,gBACZ,YAAY,kBACZ,YAAY,YACZ,MAAM;gBACS,UAAU;iBAAe,MAAM;EA+MxD"}
+{"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;gBACS,UAAU;iBAAe,MAAM;EA0MxD;AAzQD;;;;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_roundness_delta } from "./atlas_chart_roundness_delta.js";
 import { IndexedFloatMinHeap } from "../../../../collection/heap/IndexedFloatMinHeap.js";
 import { v3_dot } from "../../../vec3/v3_dot.js";
 import { EDGE_DIHEDRAL_BOUNDARY } from "../data/atlas_build_edge_dihedrals.js";
@@ -7,7 +8,7 @@ import { EDGE_DIHEDRAL_BOUNDARY } from "../data/atlas_build_edge_dihedrals.js";
  * inserted into the heap.
  * @type {number}
  */
-const REJECT = Infinity;
+export const REJECT = Infinity;
 
 /**
  * Hard reject when the normal-deviation term reaches this — `1 - dot >= 0.707`
@@ -15,14 +16,14 @@ const REJECT = Infinity;
  * xatlas's `computeCost` hard cutoff.
  * @type {number}
  */
-const NORMAL_DEVIATION_REJECT = 0.707;
+export const NORMAL_DEVIATION_REJECT = 0.707;
 
 /**
  * A heap entry is considered stale (recomputed against a drifted chart normal)
  * when its fresh cost differs from the stored cost by more than this.
  * @type {number}
  */
-const STALE_EPSILON = 1e-6;
+export const STALE_EPSILON = 1e-6;
 
 /**
  * Default segmentation weights/limits (xatlas `ChartOptions`). The texture-seam
@@ -170,12 +171,7 @@ export function atlas_segment_charts(mesh, face_areas, edge_lengths, edge_dihedr
 
         const NS = shared_len > 0 ? shared_seam / shared_len : 0;
 
-        let R = 0;
-        if (chart_area > 0 && chart_boundary > 0 && new_boundary > 0) {
-            const old_ratio = (chart_boundary * chart_boundary) / chart_area;
-            const new_ratio = (new_boundary * new_boundary) / new_area;
-            R = 1 - old_ratio / new_ratio;
-        }
+        const R = atlas_chart_roundness_delta(chart_area, chart_boundary, new_area, new_boundary);
 
         out_area = new_area;
         out_boundary = new_boundary;

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":"AAUA;;;;;;;;;;;;;;;;GAgBG;AACH,uFAJW,WAAW,YACX,MAAM;gBACS,UAAU;iBAAe,MAAM;EA6KxD"}
+{"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;gBACS,UAAU;iBAAe,MAAM;EAwKxD"}

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

@@ -1,12 +1,9 @@
 import { IndexedFloatMinHeap } from "../../../../collection/heap/IndexedFloatMinHeap.js";
 import { NULL_POINTER } from "../../topology/struct/binary/BinaryTopology.js";
-import { ATLAS_SEGMENT_DEFAULTS } from "./atlas_segment_charts.js";
+import { ATLAS_SEGMENT_DEFAULTS, NORMAL_DEVIATION_REJECT, REJECT, STALE_EPSILON } from "./atlas_segment_charts.js";
+import { atlas_chart_roundness_delta } from "./atlas_chart_roundness_delta.js";
+
 
-// These mirror atlas_segment_charts (the face-granular twin); kept local so the
-// two segmenters stay monomorphic.
-const REJECT = Infinity;
-const NORMAL_DEVIATION_REJECT = 0.707;
-const STALE_EPSILON = 1e-6;
 
 /**
  * Region-atomic chart segmentation (xatlas grows whole coplanar regions as
@@ -95,12 +92,7 @@ export function atlas_segment_charts_atomic(region_graph, region_of_face, option
 
         const NS = shared > 0 ? seam / shared : 0;
 
-        let R = 0;
-        if (chart_area > 0 && chart_boundary > 0 && new_boundary > 0) {
-            const old_ratio = (chart_boundary * chart_boundary) / chart_area;
-            const new_ratio = (new_boundary * new_boundary) / new_area;
-            R = 1 - old_ratio / new_ratio;
-        }
+        const R = atlas_chart_roundness_delta(chart_area, chart_boundary, new_area, new_boundary);
 
         out_area = new_area;
         out_boundary = new_boundary;

package/src/core/geom/3d/frustum/read_frustum_corner.d.ts

@@ -1,4 +1,9 @@
 /**
+ * Read one corner out of a packed frustum-corner buffer.
+ *
+ * Index-flavoured wrapper over {@link v3_copy_array}: corners are stored as consecutive `(x, y, z)`
+ * triples, so corner `i` starts at element `i * 3`. Overlapping source/destination ranges are safe —
+ * `v3_copy_array` reads all three components before writing any.
  *
  * @param {number[]|Float32Array|Float64Array} source
  * @param {number} source_index

package/src/core/geom/3d/frustum/read_frustum_corner.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"read_frustum_corner.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/frustum/read_frustum_corner.js"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,4CALW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,gBAClC,MAAM,eACN,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,sBAClC,MAAM,QAQhB"}
+{"version":3,"file":"read_frustum_corner.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/frustum/read_frustum_corner.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;GAWG;AACH,4CALW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,gBAClC,MAAM,eACN,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,sBAClC,MAAM,QAIhB"}

package/src/core/geom/3d/frustum/read_frustum_corner.js

@@ -1,4 +1,11 @@
+import { v3_copy_array } from "../../vec3/v3_copy_array.js";
+
 /**
+ * Read one corner out of a packed frustum-corner buffer.
+ *
+ * Index-flavoured wrapper over {@link v3_copy_array}: corners are stored as consecutive `(x, y, z)`
+ * triples, so corner `i` starts at element `i * 3`. Overlapping source/destination ranges are safe —
+ * `v3_copy_array` reads all three components before writing any.
  *
  * @param {number[]|Float32Array|Float64Array} source
  * @param {number} source_index
@@ -6,9 +13,5 @@
  * @param {number} destination_offset
  */
 export function read_frustum_corner(source, source_index, destination, destination_offset) {
-    const address = source_index * 3;
-
-    destination[destination_offset] = source[address];
-    destination[destination_offset + 1] = source[address + 1];
-    destination[destination_offset + 2] = source[address + 2];
+    v3_copy_array(destination, destination_offset, source, source_index * 3);
 }

package/src/core/geom/3d/line/line3_segment_segment_closest_point_pair.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Closest pair of points between two 3D segments, written into `out` as
+ * `(pax, pay, paz, pbx, pby, pbz)` — the point on segment A followed by the point on segment B.
+ *
+ * Wraps {@link line3_compute_segment_segment_closest_points}, which reports the closest pair as the
+ * parameters `(s, t)`. Every caller of that function immediately reconstructed both world points with the
+ * same six lines, and three of the four then took the squared distance between them — returned here.
+ *
+ * The reconstruction uses the `a + (b - a) * t` form deliberately, matching all previous call sites
+ * bit-for-bit; the algebraically equal `(1 - t) * a + t * b` is NOT the same in floating point and would
+ * perturb the contact manifolds this feeds.
+ *
+ * @param {number[]|Float32Array|Float64Array} out destination, at least 6 elements from `out_offset`
+ * @param {number} out_offset
+ * @param {number} a0x
+ * @param {number} a0y
+ * @param {number} a0z
+ * @param {number} a1x
+ * @param {number} a1y
+ * @param {number} a1z
+ * @param {number} b0x
+ * @param {number} b0y
+ * @param {number} b0z
+ * @param {number} b1x
+ * @param {number} b1y
+ * @param {number} b1z
+ * @returns {number} SQUARED distance between the two closest points
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function line3_segment_segment_closest_point_pair(out: number[] | Float32Array | Float64Array, out_offset: number, a0x: number, a0y: number, a0z: number, a1x: number, a1y: number, a1z: number, b0x: number, b0y: number, b0z: number, b1x: number, b1y: number, b1z: number): number;
+//# sourceMappingURL=line3_segment_segment_closest_point_pair.d.ts.map

package/src/core/geom/3d/line/line3_segment_segment_closest_point_pair.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"line3_segment_segment_closest_point_pair.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/line/line3_segment_segment_closest_point_pair.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,8DAnBW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,cAClC,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,GACJ,MAAM,CAuClB"}

package/src/core/geom/3d/line/line3_segment_segment_closest_point_pair.js

@@ -0,0 +1,71 @@
+import { line3_compute_segment_segment_closest_points } from "./line3_compute_segment_segment_closest_points.js";
+
+// [s, t] parameters along segment A and segment B
+const scratch_st = new Float64Array(2);
+
+/**
+ * Closest pair of points between two 3D segments, written into `out` as
+ * `(pax, pay, paz, pbx, pby, pbz)` — the point on segment A followed by the point on segment B.
+ *
+ * Wraps {@link line3_compute_segment_segment_closest_points}, which reports the closest pair as the
+ * parameters `(s, t)`. Every caller of that function immediately reconstructed both world points with the
+ * same six lines, and three of the four then took the squared distance between them — returned here.
+ *
+ * The reconstruction uses the `a + (b - a) * t` form deliberately, matching all previous call sites
+ * bit-for-bit; the algebraically equal `(1 - t) * a + t * b` is NOT the same in floating point and would
+ * perturb the contact manifolds this feeds.
+ *
+ * @param {number[]|Float32Array|Float64Array} out destination, at least 6 elements from `out_offset`
+ * @param {number} out_offset
+ * @param {number} a0x
+ * @param {number} a0y
+ * @param {number} a0z
+ * @param {number} a1x
+ * @param {number} a1y
+ * @param {number} a1z
+ * @param {number} b0x
+ * @param {number} b0y
+ * @param {number} b0z
+ * @param {number} b1x
+ * @param {number} b1y
+ * @param {number} b1z
+ * @returns {number} SQUARED distance between the two closest points
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function line3_segment_segment_closest_point_pair(
+    out, out_offset,
+    a0x, a0y, a0z, a1x, a1y, a1z,
+    b0x, b0y, b0z, b1x, b1y, b1z
+) {
+    line3_compute_segment_segment_closest_points(
+        scratch_st,
+        a0x, a0y, a0z, a1x, a1y, a1z,
+        b0x, b0y, b0z, b1x, b1y, b1z
+    );
+
+    const s = scratch_st[0];
+    const t = scratch_st[1];
+
+    const pax = a0x + (a1x - a0x) * s;
+    const pay = a0y + (a1y - a0y) * s;
+    const paz = a0z + (a1z - a0z) * s;
+
+    const pbx = b0x + (b1x - b0x) * t;
+    const pby = b0y + (b1y - b0y) * t;
+    const pbz = b0z + (b1z - b0z) * t;
+
+    out[out_offset] = pax;
+    out[out_offset + 1] = pay;
+    out[out_offset + 2] = paz;
+    out[out_offset + 3] = pbx;
+    out[out_offset + 4] = pby;
+    out[out_offset + 5] = pbz;
+
+    const dx = pax - pbx;
+    const dy = pay - pby;
+    const dz = paz - pbz;
+
+    return dx * dx + dy * dy + dz * dz;
+}

package/src/core/geom/3d/mat4/m4_compose.d.ts

@@ -1,4 +1,9 @@
 /**
+ * Compose a 4x4 transform matrix from a position, a rotation quaternion and a (non-uniform) scale.
+ * `result = T * R * S`.
+ *
+ * Object-argument face of {@link m4_from_rotation_translation_scale_scalar}; see
+ * {@link m4_from_rotation_translation_scale} for the flat-array flavour.
  *
  * @param {number[]|Float32Array|mat4} result
  * @param { { x:number, y:number, z:number } } position

package/src/core/geom/3d/mat4/m4_compose.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"m4_compose.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/mat4/m4_compose.js"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,mCALW,MAAM,EAAE,GAAC,YAAY,OAAK;OACrB,MAAM;OAAI,MAAM;OAAI,MAAM;;OAC1B,MAAM;OAAI,MAAM;OAAI,MAAM;OAAI,MAAM;;OACpC,MAAM;OAAI,MAAM;OAAI,MAAM;SA+CzC"}
+{"version":3,"file":"m4_compose.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/mat4/m4_compose.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;GAWG;AACH,mCALW,MAAM,EAAE,GAAC,YAAY,OAAK,YACzB;IAAE,CAAC,EAAC,MAAM,CAAC;IAAC,CAAC,EAAC,MAAM,CAAC;IAAC,CAAC,EAAC,MAAM,CAAA;CAAE,YAChC;IAAE,CAAC,EAAC,MAAM,CAAC;IAAC,CAAC,EAAC,MAAM,CAAC;IAAC,CAAC,EAAC,MAAM,CAAC;IAAC,CAAC,EAAC,MAAM,CAAA;CAAE,SAC1C;IAAE,CAAC,EAAC,MAAM,CAAC;IAAC,CAAC,EAAC,MAAM,CAAC;IAAC,CAAC,EAAC,MAAM,CAAA;CAAE,QAS3C"}