@woosh/meep-engine 2.169.1 → 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/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/Vector2.d.ts.map

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

package/src/core/geom/Vector2.js

@@ -1,3 +1,4 @@
+import { hash_mix2 } from "../math/hash/hash_mix2.js";
 import { assert } from "../assert.js";
 import Signal from "../events/signal/Signal.js";
 import { clamp } from "../math/clamp.js";
@@ -637,7 +638,7 @@ export class Vector2 extends Float64Array {
         const x = computeHashFloat(this[0]);
         const y = computeHashFloat(this[1]);
 
-        return ((x << 5) - x) + y;
+        return hash_mix2(x, y);
     }
 
     /**

package/src/core/geom/random/random_orthonormal_basis.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Write a UNIFORMLY random orthonormal 3x3 basis into `result` (row-major, 9 elements), built around a
+ * uniformly-random unit direction that becomes the third (Z) row.
+ *
+ * WHY this exists: rotating a deterministic direction set (a Fibonacci sphere lattice, a fixed cone fan)
+ * by a fresh random basis decorrelates the lattice from the geometry it samples, which is what removes the
+ * structured bias a fixed lattice bakes in. Every sampler that wants that has to (a) draw a uniform point
+ * on the sphere and (b) complete it to a basis — two easy-to-get-wrong steps (the uniform axis must be
+ * `z ~ U(-1,1)`, NOT a uniform polar angle, and the ring radius needs the `max(0, ...)` guard so a
+ * `z = ±1` draw cannot produce `sqrt` of a negative rounding residue). Both acoustic ray samplers had
+ * inlined their own copy of exactly these four lines.
+ *
+ * The direction is drawn as `z = 2·random() − 1` FIRST and the azimuth second — the RNG consumption order
+ * is part of the contract, since callers are seeded and reproducible.
+ *
+ * @param {number[]|Float32Array|Float64Array} result receives 9 elements: rows X, Y, Z (Z is the random direction)
+ * @param {number} result_offset
+ * @param {function():number} random RNG in [0, 1); consumed exactly twice
+ */
+export function random_orthonormal_basis(result: number[] | Float32Array | Float64Array, result_offset: number, random: () => number): void;
+//# sourceMappingURL=random_orthonormal_basis.d.ts.map

package/src/core/geom/random/random_orthonormal_basis.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"random_orthonormal_basis.d.ts","sourceRoot":"","sources":["../../../../../src/core/geom/random/random_orthonormal_basis.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;GAkBG;AACH,iDAJW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,iBAClC,MAAM,gBACK,MAAM,QAW3B"}

package/src/core/geom/random/random_orthonormal_basis.js

@@ -0,0 +1,31 @@
+import { v3_orthonormal_matrix_from_normal } from "../vec3/v3_orthonormal_matrix_from_normal.js";
+
+/**
+ * Write a UNIFORMLY random orthonormal 3x3 basis into `result` (row-major, 9 elements), built around a
+ * uniformly-random unit direction that becomes the third (Z) row.
+ *
+ * WHY this exists: rotating a deterministic direction set (a Fibonacci sphere lattice, a fixed cone fan)
+ * by a fresh random basis decorrelates the lattice from the geometry it samples, which is what removes the
+ * structured bias a fixed lattice bakes in. Every sampler that wants that has to (a) draw a uniform point
+ * on the sphere and (b) complete it to a basis — two easy-to-get-wrong steps (the uniform axis must be
+ * `z ~ U(-1,1)`, NOT a uniform polar angle, and the ring radius needs the `max(0, ...)` guard so a
+ * `z = ±1` draw cannot produce `sqrt` of a negative rounding residue). Both acoustic ray samplers had
+ * inlined their own copy of exactly these four lines.
+ *
+ * The direction is drawn as `z = 2·random() − 1` FIRST and the azimuth second — the RNG consumption order
+ * is part of the contract, since callers are seeded and reproducible.
+ *
+ * @param {number[]|Float32Array|Float64Array} result receives 9 elements: rows X, Y, Z (Z is the random direction)
+ * @param {number} result_offset
+ * @param {function():number} random RNG in [0, 1); consumed exactly twice
+ */
+export function random_orthonormal_basis(result, result_offset, random) {
+    const z = 2 * random() - 1;
+    const azimuth = 2 * Math.PI * random();
+    const ring = Math.sqrt(Math.max(0, 1 - z * z));
+
+    v3_orthonormal_matrix_from_normal(
+        result, result_offset,
+        ring * Math.cos(azimuth), ring * Math.sin(azimuth), z
+    );
+}

package/src/core/geom/vec2/v2_rotate.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Rotate a 2d vector around the origin by an angle.
+ *
+ * Before this existed the four-line body was inlined at every site that needed it, which made the
+ * sign convention a copy-paste artifact instead of a documented contract. Keep new callers here.
+ *
+ * The rotation matches the standard 2d rotation matrix `[cos, -sin; sin, cos]`, i.e.
+ * counter-clockwise in a Y-up frame and clockwise in the Y-down frames used by grid/screen space.
+ * Callers own any rounding or snapping of the result.
+ *
+ * @param {Float64Array|Float32Array|number[]} result
+ * @param {number} result_offset
+ * @param {number} x
+ * @param {number} y
+ * @param {number} angle in radians
+ */
+export function v2_rotate(result: Float64Array | Float32Array | number[], result_offset: number, x: number, y: number, angle: number): void;
+//# sourceMappingURL=v2_rotate.d.ts.map