@woosh/meep-engine 2.169.0 → 2.169.2

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

@@ -1 +1 @@
-{"version":3,"file":"bt_mesh_face_find_path_polyanya.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/core/geom/3d/topology/struct/binary/query/bt_mesh_face_find_path_polyanya.js"],"names":[],"mappings":"AAwSA;;;;;;;;;;;;;;GAcG;AACH,wDAZW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,gCAElC,MAAM,MACN,MAAM,MACN,MAAM,cACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,aACN,MAAM,GACJ,MAAM,CA+HlB"}
+{"version":3,"file":"bt_mesh_face_find_path_polyanya.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/core/geom/3d/topology/struct/binary/query/bt_mesh_face_find_path_polyanya.js"],"names":[],"mappings":"AA6RA;;;;;;;;;;;;;;GAcG;AACH,wDAZW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,gCAElC,MAAM,MACN,MAAM,MACN,MAAM,cACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,aACN,MAAM,GACJ,MAAM,CA+HlB"}

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

@@ -1,3 +1,5 @@
+import { bt_face_read_triangle_vertices } from "./bt_face_read_triangle.js";
+import { bt_vertex_distance_to_vertex } from "./bt_vertex_distance_to_vertex.js";
 import { Uint32Heap4 } from "../../../../../../collection/heap/Uint32Heap4.js";
 import {
     line2_segment_intersection_fraction_2d
@@ -87,24 +89,11 @@ function touch_distance(rx, ry, i0x, i0y, i1x, i1y, gx, gy) {
 // ---- mesh helpers ----------------------------------------------------------------------------------
 
 const _va = new Float64Array(3), _vb = new Float64Array(3), _vc = new Float64Array(3);
-const _qa = new Float64Array(3), _qb = new Float64Array(3); // distance reads, kept off _va/_vb/_vc
+const _qa = new Float64Array(3); // vertex-coordinate read, kept off _va/_vb/_vc
 
 const _tri = [0, 0, 0];
-function triangle_vertices(topology, face) {
-    const l0 = topology.face_read_loop(face);
-    const l1 = topology.loop_read_next(l0);
-    const l2 = topology.loop_read_next(l1);
-    _tri[0] = topology.loop_read_vertex(l0);
-    _tri[1] = topology.loop_read_vertex(l1);
-    _tri[2] = topology.loop_read_vertex(l2);
-}
 
-/** 3D distance between two vertices. */
-function vid_distance_3d(topology, va, vb) {
-    topology.vertex_read_coordinate(_qa, 0, va);
-    topology.vertex_read_coordinate(_qb, 0, vb);
-    return Math.hypot(_qa[0] - _qb[0], _qa[1] - _qb[1], _qa[2] - _qb[2]);
-}
+
 
 /** The face across edge (va,vb) other than `face`, or NULL_POINTER if that edge is a boundary. */
 function neighbour_across(topology, face, va, vb) {
@@ -135,15 +124,15 @@ function neighbour_across(topology, face, va, vb) {
  */
 const _apex = new Float64Array(2);
 function unfold_apex(topology, face, e0v, e1v, e0x, e0y, e1x, e1y) {
-    triangle_vertices(topology, face);
+    bt_face_read_triangle_vertices(_tri, topology, face);
     let apex = -1, e0_before_e1 = false;
     for (let i = 0; i < 3; i++) {
         if (_tri[i] === e0v && _tri[(i + 1) % 3] === e1v) e0_before_e1 = true;
         if (_tri[i] !== e0v && _tri[i] !== e1v) apex = _tri[i];
     }
 
-    const dac = vid_distance_3d(topology, e0v, apex);
-    const dbc = vid_distance_3d(topology, e1v, apex);
+    const dac = bt_vertex_distance_to_vertex(topology, e0v, apex);
+    const dbc = bt_vertex_distance_to_vertex(topology, e1v, apex);
     const ex = e1x - e0x, ey = e1y - e0y;
     const d = Math.hypot(ex, ey);
     const a = (dac * dac - dbc * dbc + d * d) / (2 * d); // foot of the apex along the edge
@@ -212,7 +201,7 @@ function is_corner(topology, vid) {
         const ox = _va[0], oy = _va[1], oz = _va[2];
         let angle = 0;
         for (const f of _corner_faces) {
-            triangle_vertices(topology, f);
+            bt_face_read_triangle_vertices(_tri, topology, f);
             let a = -1, b = -1;
             for (let i = 0; i < 3; i++) {
                 if (_tri[i] !== vid) { if (a === -1) a = _tri[i]; else b = _tri[i]; }
@@ -325,17 +314,17 @@ export function bt_mesh_face_find_path_polyanya(output, topology, sx, sy, sz, st
     }
 
     // goal barycentric, so the goal can be unfolded into any frame that reaches the goal face
-    triangle_vertices(topology, goal_face);
+    bt_face_read_triangle_vertices(_tri, topology, goal_face);
     _goal_v0 = _tri[0]; _goal_v1 = _tri[1]; _goal_v2 = _tri[2];
     barycentric_3d(topology, _goal_v0, _goal_v1, _goal_v2, gx, gy, gz, _bw);
     _goal_w0 = _bw[0]; _goal_w1 = _bw[1]; _goal_w2 = _bw[2];
 
     // lay the start face out in 2D (CCW: apex on the +y/left side of edge a->b) and place the start point
-    triangle_vertices(topology, start_face);
+    bt_face_read_triangle_vertices(_tri, topology, start_face);
     const a = _tri[0], b = _tri[1], c = _tri[2];
-    const dab = vid_distance_3d(topology, a, b);
-    const dac = vid_distance_3d(topology, a, c);
-    const dbc = vid_distance_3d(topology, b, c);
+    const dab = bt_vertex_distance_to_vertex(topology, a, b);
+    const dac = bt_vertex_distance_to_vertex(topology, a, c);
+    const dbc = bt_vertex_distance_to_vertex(topology, b, c);
     const cx = (dac * dac - dbc * dbc + dab * dab) / (2 * dab);
     let ch2 = dac * dac - cx * cx; if (ch2 < 0) ch2 = 0;
     const cy = Math.sqrt(ch2); // p_a=(0,0), p_b=(dab,0), p_c=(cx,cy)

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

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

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

@@ -1,3 +1,4 @@
+import { bt_mesh_build_surface_triangle_bvh, SURFACE_PARITY_RAY_COUNT, SURFACE_PARITY_RAY_DIRECTIONS } from "./bt_mesh_surface_ray_parity.js";
 import { assert } from "../../../../../../assert.js";
 import { BVH, NULL_NODE } from "../../../../../../bvh2/bvh3/BVH.js";
 import { bvh_query_user_data_ray } from "../../../../../../bvh2/bvh3/query/bvh_query_user_data_ray.js";
@@ -9,12 +10,6 @@ import { tri3_ray_intersection } from "../../../../triangle/tri3_ray_intersectio
 // majority vote. Same scheme as tetrahedral_mesh_carve_outside_surface — a
 // single ray is fragile at grazing edges, three independent rays settle the
 // vote correctly except in vanishingly improbable configurations.
-const RAY_DIRECTIONS = [
-    0.97123,  0.18927,  0.14431,
-    0.34219,  0.91283, -0.22971,
-   -0.51237,  0.27894,  0.81235,
-];
-const RAY_COUNT = RAY_DIRECTIONS.length / 3;
 
 // Stratification offset cap (as a fraction of a cell). 0 = perfect grid
 // (worst case for Delaunay sliver count), 0.5 = candidates can sit anywhere
@@ -22,47 +17,6 @@ const RAY_COUNT = RAY_DIRECTIONS.length / 3;
 // face/edge alignments without losing the locality benefits of the grid.
 const JITTER = 0.35;
 
-/**
- * Build a BVH whose leaves are the surface's triangle faces. User data on
- * each leaf is the source face ID.
- */
-function build_surface_bvh(bvh, mesh) {
-    bvh.release_all();
-
-    const face_count = mesh.faces.size;
-    const v = [0, 0, 0];
-
-    for (let f = 0; f < face_count; f++) {
-        if (!mesh.faces.is_allocated(f)) continue;
-
-        const l0 = mesh.face_read_loop(f);
-        const l1 = mesh.loop_read_next(l0);
-        const l2 = mesh.loop_read_next(l1);
-
-        const v0 = mesh.loop_read_vertex(l0);
-        const v1 = mesh.loop_read_vertex(l1);
-        const v2 = mesh.loop_read_vertex(l2);
-
-        mesh.vertex_read_coordinate(v, 0, v0);
-        let minx = v[0], miny = v[1], minz = v[2];
-        let maxx = v[0], maxy = v[1], maxz = v[2];
-
-        mesh.vertex_read_coordinate(v, 0, v1);
-        if (v[0] < minx) minx = v[0]; else if (v[0] > maxx) maxx = v[0];
-        if (v[1] < miny) miny = v[1]; else if (v[1] > maxy) maxy = v[1];
-        if (v[2] < minz) minz = v[2]; else if (v[2] > maxz) maxz = v[2];
-
-        mesh.vertex_read_coordinate(v, 0, v2);
-        if (v[0] < minx) minx = v[0]; else if (v[0] > maxx) maxx = v[0];
-        if (v[1] < miny) miny = v[1]; else if (v[1] > maxy) maxy = v[1];
-        if (v[2] < minz) minz = v[2]; else if (v[2] > maxz) maxz = v[2];
-
-        const node = bvh.allocate_node();
-        bvh.node_set_user_data(node, f);
-        bvh.node_set_aabb_primitive(node, minx, miny, minz, maxx, maxy, maxz);
-        bvh.insert_leaf(node);
-    }
-}
 
 const ray_hit = new SurfacePoint3();
 const ray_candidates = [];
@@ -71,7 +25,7 @@ const vb = [0, 0, 0];
 const vc = [0, 0, 0];
 
 /**
- * Parity ray-cast across `RAY_COUNT` directions; majority decides
+ * Parity ray-cast across `SURFACE_PARITY_RAY_COUNT` directions; majority decides
  * inside/outside. Returns true if (strict majority of) rays cross the
  * surface an odd number of times.
  */
@@ -81,10 +35,10 @@ function point_is_inside(mesh, bvh, ox, oy, oz) {
 
     let inside_votes = 0;
 
-    for (let r = 0; r < RAY_COUNT; r++) {
-        const dx = RAY_DIRECTIONS[r * 3];
-        const dy = RAY_DIRECTIONS[r * 3 + 1];
-        const dz = RAY_DIRECTIONS[r * 3 + 2];
+    for (let r = 0; r < SURFACE_PARITY_RAY_COUNT; r++) {
+        const dx = SURFACE_PARITY_RAY_DIRECTIONS[r * 3];
+        const dy = SURFACE_PARITY_RAY_DIRECTIONS[r * 3 + 1];
+        const dz = SURFACE_PARITY_RAY_DIRECTIONS[r * 3 + 2];
 
         const candidate_count = bvh_query_user_data_ray(
             ray_candidates, 0,
@@ -119,7 +73,7 @@ function point_is_inside(mesh, bvh, ox, oy, oz) {
         if ((hits & 1) === 1) inside_votes++;
     }
 
-    return inside_votes * 2 > RAY_COUNT;
+    return inside_votes * 2 > SURFACE_PARITY_RAY_COUNT;
 }
 
 /**
@@ -195,7 +149,7 @@ export function bt_mesh_sample_interior_grid_points(mesh, cells_per_dim, seed =
 
     // Build BVH over surface triangles for the inside-test.
     const bvh = new BVH();
-    build_surface_bvh(bvh, mesh);
+    bt_mesh_build_surface_triangle_bvh(bvh, mesh);
 
     const rng = seededRandom(seed);
     const out = []; // grow dynamically; copy to Float32Array at the end

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

@@ -0,0 +1,35 @@
+/**
+ * Build a BVH whose leaves are the mesh's triangular faces, each leaf's `user_data` being the source face
+ * id. The BVH is cleared first, so it may be reused across calls.
+ *
+ * Shared by the tetrahedral carver and the interior-point sampler, which each carried a token-identical
+ * copy of this loop.
+ *
+ * @param {BVH} bvh destination, released and refilled
+ * @param {BinaryTopology} mesh surface mesh
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function bt_mesh_build_surface_triangle_bvh(bvh: BVH, mesh: BinaryTopology): void;
+/**
+ * Three irrational, mutually unrelated ray directions for the parity-raycast majority vote used by
+ * point-in-closed-surface tests.
+ *
+ * A single ray is fragile at grazing edges and vertices, where a hit can be counted twice or not at all;
+ * three independent directions settle the vote correctly except in vanishingly improbable configurations.
+ *
+ * Each row is roughly unit length so the AABB-vs-ray slab test in the BVH query does not degenerate.
+ * Hand-picked rather than randomised so the classification is fully deterministic — which is why these
+ * digits must not be "tidied": two callers previously carried them digit-for-digit and any edit to one
+ * copy would silently have given the two classifiers different tie-breaking on the same mesh.
+ *
+ * @type {number[]}
+ */
+export const SURFACE_PARITY_RAY_DIRECTIONS: number[];
+/**
+ * Number of rays in {@link SURFACE_PARITY_RAY_DIRECTIONS}.
+ * @type {number}
+ */
+export const SURFACE_PARITY_RAY_COUNT: number;
+//# sourceMappingURL=bt_mesh_surface_ray_parity.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"bt_mesh_surface_ray_parity.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/core/geom/3d/topology/struct/binary/query/bt_mesh_surface_ray_parity.js"],"names":[],"mappings":"AA0BA;;;;;;;;;;;;GAYG;AACH,yFAwCC;AA/ED;;;;;;;;;;;;;GAaG;AACH,4CAFU,MAAM,EAAE,CAMhB;AAEF;;;GAGG;AACH,uCAFU,MAAM,CAEiE"}

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

@@ -0,0 +1,82 @@
+/**
+ * Three irrational, mutually unrelated ray directions for the parity-raycast majority vote used by
+ * point-in-closed-surface tests.
+ *
+ * A single ray is fragile at grazing edges and vertices, where a hit can be counted twice or not at all;
+ * three independent directions settle the vote correctly except in vanishingly improbable configurations.
+ *
+ * Each row is roughly unit length so the AABB-vs-ray slab test in the BVH query does not degenerate.
+ * Hand-picked rather than randomised so the classification is fully deterministic — which is why these
+ * digits must not be "tidied": two callers previously carried them digit-for-digit and any edit to one
+ * copy would silently have given the two classifiers different tie-breaking on the same mesh.
+ *
+ * @type {number[]}
+ */
+export const SURFACE_PARITY_RAY_DIRECTIONS = [
+    0.97123, 0.18927, 0.14431,
+    0.34219, 0.91283, -0.22971,
+    -0.51237, 0.27894, 0.81235,
+];
+
+/**
+ * Number of rays in {@link SURFACE_PARITY_RAY_DIRECTIONS}.
+ * @type {number}
+ */
+export const SURFACE_PARITY_RAY_COUNT = SURFACE_PARITY_RAY_DIRECTIONS.length / 3;
+
+/**
+ * Build a BVH whose leaves are the mesh's triangular faces, each leaf's `user_data` being the source face
+ * id. The BVH is cleared first, so it may be reused across calls.
+ *
+ * Shared by the tetrahedral carver and the interior-point sampler, which each carried a token-identical
+ * copy of this loop.
+ *
+ * @param {BVH} bvh destination, released and refilled
+ * @param {BinaryTopology} mesh surface mesh
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function bt_mesh_build_surface_triangle_bvh(bvh, mesh) {
+    bvh.release_all();
+
+    const face_count = mesh.faces.size;
+    const v = scratch_coordinate;
+
+    for (let f = 0; f < face_count; f++) {
+        if (!mesh.faces.is_allocated(f)) {
+            continue;
+        }
+
+        const l0 = mesh.face_read_loop(f);
+        const l1 = mesh.loop_read_next(l0);
+        const l2 = mesh.loop_read_next(l1);
+
+        const v0 = mesh.loop_read_vertex(l0);
+        const v1 = mesh.loop_read_vertex(l1);
+        const v2 = mesh.loop_read_vertex(l2);
+
+        mesh.vertex_read_coordinate(v, 0, v0);
+
+        let minx = v[0], miny = v[1], minz = v[2];
+        let maxx = v[0], maxy = v[1], maxz = v[2];
+
+        mesh.vertex_read_coordinate(v, 0, v1);
+        if (v[0] < minx) minx = v[0]; else if (v[0] > maxx) maxx = v[0];
+        if (v[1] < miny) miny = v[1]; else if (v[1] > maxy) maxy = v[1];
+        if (v[2] < minz) minz = v[2]; else if (v[2] > maxz) maxz = v[2];
+
+        mesh.vertex_read_coordinate(v, 0, v2);
+        if (v[0] < minx) minx = v[0]; else if (v[0] > maxx) maxx = v[0];
+        if (v[1] < miny) miny = v[1]; else if (v[1] > maxy) maxy = v[1];
+        if (v[2] < minz) minz = v[2]; else if (v[2] > maxz) maxz = v[2];
+
+        const node = bvh.allocate_node();
+
+        bvh.node_set_user_data(node, f);
+        bvh.node_set_aabb_primitive(node, minx, miny, minz, maxx, maxy, maxz);
+        bvh.insert_leaf(node);
+    }
+}
+
+const scratch_coordinate = [0, 0, 0];

package/src/core/geom/3d/topology/util/mesh_flood_fill.d.ts

@@ -1,7 +1,7 @@
 /**
  *
  * @param {TopoTriangle[]} initial_set indices of triangles that make up initial set, these are triangles that we start from, they will also be included in the resulting set
- * @param {function(tri:TopoTriangle, prev:TopoTriangle):boolean} filter decides whether a triangle should be included or not
+ * @param {(tri: TopoTriangle, prev: TopoTriangle) => boolean} filter decides whether a triangle should be included or not
  * @returns {TopoTriangle[]} set of selected triangles, will include initial set as well
  */
 export function mesh_flood_fill({ initial_set, filter }: TopoTriangle[]): TopoTriangle[];

package/src/core/geom/3d/topology/util/mesh_flood_fill.js

@@ -9,7 +9,7 @@ const neighbours = [];
 /**
  *
  * @param {TopoTriangle[]} initial_set indices of triangles that make up initial set, these are triangles that we start from, they will also be included in the resulting set
- * @param {function(tri:TopoTriangle, prev:TopoTriangle):boolean} filter decides whether a triangle should be included or not
+ * @param {(tri: TopoTriangle, prev: TopoTriangle) => boolean} filter decides whether a triangle should be included or not
  * @returns {TopoTriangle[]} set of selected triangles, will include initial set as well
  */
 export function mesh_flood_fill({

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

@@ -0,0 +1,29 @@
+/**
+ * Closest point to `(px, py, pz)` on the triangle `ABC`, written into `out` as `(x, y, z)`.
+ *
+ * Wraps {@link tri3_closest_point_barycentric}, which reports the closest point as barycentric weights
+ * `[u, v]` (the weight of C being the implied `1 - u - v`). Every caller of that function immediately
+ * performed this same reconstruction, and each named the third weight differently — which is how one of
+ * them could quietly get the ordering wrong.
+ *
+ * @param {number[]|Float32Array|Float64Array} out destination for the closest point `(x, y, z)`
+ * @param {number} out_offset
+ * @param {number} px
+ * @param {number} py
+ * @param {number} pz
+ * @param {number} ax
+ * @param {number} ay
+ * @param {number} az
+ * @param {number} bx
+ * @param {number} by
+ * @param {number} bz
+ * @param {number} cx
+ * @param {number} cy
+ * @param {number} cz
+ * @returns {number} the SQUARED distance from the query point to the closest point
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function tri3_closest_point(out: number[] | Float32Array | Float64Array, out_offset: number, px: number, py: number, pz: number, ax: number, ay: number, az: number, bx: number, by: number, bz: number, cx: number, cy: number, cz: number): number;
+//# sourceMappingURL=tri3_closest_point.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tri3_closest_point.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/triangle/tri3_closest_point.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wCAnBW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,cAClC,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,MAAM,CAqClB"}

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

@@ -0,0 +1,65 @@
+import { tri3_closest_point_barycentric } from "./tri3_closest_point_barycentric.js";
+
+// barycentric weights of the closest point, [u, v] with the third weight implied
+const scratch_barycentric = new Float64Array(2);
+
+/**
+ * Closest point to `(px, py, pz)` on the triangle `ABC`, written into `out` as `(x, y, z)`.
+ *
+ * Wraps {@link tri3_closest_point_barycentric}, which reports the closest point as barycentric weights
+ * `[u, v]` (the weight of C being the implied `1 - u - v`). Every caller of that function immediately
+ * performed this same reconstruction, and each named the third weight differently — which is how one of
+ * them could quietly get the ordering wrong.
+ *
+ * @param {number[]|Float32Array|Float64Array} out destination for the closest point `(x, y, z)`
+ * @param {number} out_offset
+ * @param {number} px
+ * @param {number} py
+ * @param {number} pz
+ * @param {number} ax
+ * @param {number} ay
+ * @param {number} az
+ * @param {number} bx
+ * @param {number} by
+ * @param {number} bz
+ * @param {number} cx
+ * @param {number} cy
+ * @param {number} cz
+ * @returns {number} the SQUARED distance from the query point to the closest point
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function tri3_closest_point(
+    out, out_offset,
+    px, py, pz,
+    ax, ay, az,
+    bx, by, bz,
+    cx, cy, cz
+) {
+    tri3_closest_point_barycentric(
+        scratch_barycentric, 0,
+        px, py, pz,
+        ax, ay, az,
+        bx, by, bz,
+        cx, cy, cz
+    );
+
+    const u = scratch_barycentric[0];
+    const v = scratch_barycentric[1];
+    const w = 1 - u - v;
+
+    const qx = u * ax + v * bx + w * cx;
+    const qy = u * ay + v * by + w * cy;
+    const qz = u * az + v * bz + w * cz;
+
+    out[out_offset] = qx;
+    out[out_offset + 1] = qy;
+    out[out_offset + 2] = qz;
+
+    const dx = qx - px;
+    const dy = qy - py;
+    const dz = qz - pz;
+
+    return dx * dx + dy * dy + dz * dz;
+}

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

@@ -0,0 +1,42 @@
+/**
+ * Flatten a 3D triangle into its own isometric 2D frame: vertex A at the origin, vertex B on the +x axis,
+ * vertex C in the upper half-plane. Writes `[len_ab, x_c, y_c]` into `out` — vertex B is implicitly
+ * `(len_ab, 0)` and vertex A is implicitly `(0, 0)`.
+ *
+ * "Isometric" means edge lengths and the interior angle at A are preserved exactly, which is what makes
+ * this the standard first step of any conformal / ARAP / LSCM / BFF parameterisation and of geodesic
+ * triangle unfolding: the flattened triangle is congruent to the original, so all per-triangle intrinsic
+ * quantities can be computed in 2D.
+ *
+ * DEGENERATE EDGE: when A and B coincide the frame has no direction, `inv1` is forced to 0, and the result
+ * is `[0, 0, 0]` rather than NaN.
+ *
+ * @param {number[]|Float32Array|Float64Array} out destination for `[len_ab, x_c, y_c]`
+ * @param {number} out_offset
+ * @param {number} ax
+ * @param {number} ay
+ * @param {number} az
+ * @param {number} bx
+ * @param {number} by
+ * @param {number} bz
+ * @param {number} cx
+ * @param {number} cy
+ * @param {number} cz
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function tri3_flatten_isometric(out: number[] | Float32Array | Float64Array, out_offset: number, ax: number, ay: number, az: number, bx: number, by: number, bz: number, cx: number, cy: number, cz: number): void;
+/**
+ * Indexed form of {@link tri3_flatten_isometric}: reads the three vertices out of a flat
+ * `(x, y, z)`-per-vertex position buffer.
+ *
+ * @param {number[]|Float32Array|Float64Array} out destination for `[len_ab, x_c, y_c]`
+ * @param {number} out_offset
+ * @param {number[]|Float32Array|Float64Array} positions flat `(x, y, z)` per vertex
+ * @param {number} i0 index of vertex A
+ * @param {number} i1 index of vertex B
+ * @param {number} i2 index of vertex C
+ */
+export function tri3_flatten_isometric_indexed(out: number[] | Float32Array | Float64Array, out_offset: number, positions: number[] | Float32Array | Float64Array, i0: number, i1: number, i2: number): void;
+//# sourceMappingURL=tri3_flatten_isometric.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tri3_flatten_isometric.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/triangle/tri3_flatten_isometric.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,4CAfW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,cAClC,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QA6BhB;AAED;;;;;;;;;;GAUG;AACH,oDAPW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,cAClC,MAAM,aACN,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,MAClC,MAAM,MACN,MAAM,MACN,MAAM,QAehB"}

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

@@ -0,0 +1,79 @@
+/**
+ * Flatten a 3D triangle into its own isometric 2D frame: vertex A at the origin, vertex B on the +x axis,
+ * vertex C in the upper half-plane. Writes `[len_ab, x_c, y_c]` into `out` — vertex B is implicitly
+ * `(len_ab, 0)` and vertex A is implicitly `(0, 0)`.
+ *
+ * "Isometric" means edge lengths and the interior angle at A are preserved exactly, which is what makes
+ * this the standard first step of any conformal / ARAP / LSCM / BFF parameterisation and of geodesic
+ * triangle unfolding: the flattened triangle is congruent to the original, so all per-triangle intrinsic
+ * quantities can be computed in 2D.
+ *
+ * DEGENERATE EDGE: when A and B coincide the frame has no direction, `inv1` is forced to 0, and the result
+ * is `[0, 0, 0]` rather than NaN.
+ *
+ * @param {number[]|Float32Array|Float64Array} out destination for `[len_ab, x_c, y_c]`
+ * @param {number} out_offset
+ * @param {number} ax
+ * @param {number} ay
+ * @param {number} az
+ * @param {number} bx
+ * @param {number} by
+ * @param {number} bz
+ * @param {number} cx
+ * @param {number} cy
+ * @param {number} cz
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function tri3_flatten_isometric(
+    out, out_offset,
+    ax, ay, az,
+    bx, by, bz,
+    cx, cy, cz
+) {
+    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;
+
+    // unit vector along AB -- the +x axis of the local frame
+    const ux = e1x * inv1, uy = e1y * inv1, uz = e1z * inv1;
+
+    const e2x = cx - ax, e2y = cy - ay, e2z = cz - az;
+
+    // x of C is its projection onto the frame axis; y is the length of what remains
+    const x3 = e2x * ux + e2y * uy + e2z * uz;
+
+    const px = e2x - x3 * ux, py = e2y - x3 * uy, pz = e2z - x3 * uz;
+
+    out[out_offset] = len1;
+    out[out_offset + 1] = x3;
+    out[out_offset + 2] = Math.sqrt(px * px + py * py + pz * pz);
+}
+
+/**
+ * Indexed form of {@link tri3_flatten_isometric}: reads the three vertices out of a flat
+ * `(x, y, z)`-per-vertex position buffer.
+ *
+ * @param {number[]|Float32Array|Float64Array} out destination for `[len_ab, x_c, y_c]`
+ * @param {number} out_offset
+ * @param {number[]|Float32Array|Float64Array} positions flat `(x, y, z)` per vertex
+ * @param {number} i0 index of vertex A
+ * @param {number} i1 index of vertex B
+ * @param {number} i2 index of vertex C
+ */
+export function tri3_flatten_isometric_indexed(
+    out, out_offset,
+    positions,
+    i0, i1, i2
+) {
+    const a = i0 * 3, b = i1 * 3, c = i2 * 3;
+
+    tri3_flatten_isometric(
+        out, out_offset,
+        positions[a], positions[a + 1], positions[a + 2],
+        positions[b], positions[b + 1], positions[b + 2],
+        positions[c], positions[c + 1], positions[c + 2]
+    );
+}

package/src/core/geom/3d/util/aabb3_emit_point_grid.d.ts

@@ -3,8 +3,8 @@
  * actual spacing will be justified to provide even distanced along each dimension separately
  * @param {AABB3} aabb3
  * @param {number} spacing
- * @param {function(x:number,y:number,z:number)} callback
+ * @param {(x: number, y: number, z: number) => void} callback
  * @returns {number} total number of points placed
  */
-export function aabb3_emit_point_grid(aabb3: AABB3, spacing: number, callback: any): number;
+export function aabb3_emit_point_grid(aabb3: AABB3, spacing: number, callback: (x: number, y: number, z: number) => void): number;
 //# sourceMappingURL=aabb3_emit_point_grid.d.ts.map

package/src/core/geom/3d/util/aabb3_emit_point_grid.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"aabb3_emit_point_grid.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/util/aabb3_emit_point_grid.js"],"names":[],"mappings":"AAEA;;;;;;;GAOG;AACH,6DAJW,MAAM,kBAEJ,MAAM,CAiClB"}
+{"version":3,"file":"aabb3_emit_point_grid.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/util/aabb3_emit_point_grid.js"],"names":[],"mappings":"AAEA;;;;;;;GAOG;AACH,6DAJW,MAAM,gBACF,MAAM,KAAK,MAAM,KAAK,MAAM,KAAK,IAAI,GACvC,MAAM,CAiClB"}

package/src/core/geom/3d/util/aabb3_emit_point_grid.js

@@ -5,7 +5,7 @@ import { max2 } from "../../../math/max2.js";
  * actual spacing will be justified to provide even distanced along each dimension separately
  * @param {AABB3} aabb3
  * @param {number} spacing
- * @param {function(x:number,y:number,z:number)} callback
+ * @param {(x: number, y: number, z: number) => void} callback
  * @returns {number} total number of points placed
  */
 export function aabb3_emit_point_grid(aabb3, spacing, callback) {

package/src/core/geom/Quaternion.d.ts

@@ -437,11 +437,11 @@ export class Quaternion extends Float64Array implements Iterable<number> {
     slerp(other: Quaternion, t: number): this;
     /**
      *
-     * @param {function(x:number,y:number,z:number,w:number)} handler
+     * @param {(x: number, y: number, z: number, w: number) => void} handler
      * @param {*} [thisArg]
      * @returns {this}
      */
-    process(handler: any, thisArg?: any): this;
+    process(handler: (x: number, y: number, z: number, w: number) => void, thisArg?: any): this;
     /**
      *
      * @param {Quaternion} other

package/src/core/geom/Quaternion.d.ts.map

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

package/src/core/geom/Quaternion.js

@@ -1267,7 +1267,7 @@ export class Quaternion extends Float64Array {
 
     /**
      *
-     * @param {function(x:number,y:number,z:number,w:number)} handler
+     * @param {(x: number, y: number, z: number, w: number) => void} handler
      * @param {*} [thisArg]
      * @returns {this}
      */