@woosh/meep-engine 2.155.0 → 2.156.0

package/src/core/geom/2d/r-tree/StaticR2Tree.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"StaticR2Tree.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/2d/r-tree/StaticR2Tree.js"],"names":[],"mappings":"AAoEA;;;GAGG;AACH;IAEI;;;OAGG;IACH,sBAAc;IAEd;;;;OAIG;IACH,+BAAc;IAEd;;;;OAIG;IACH,4BAAwB;IAExB;;;;OAIG;IACH,0BAAsB;IAOtB;;;OAGG;IACH,kBAFW,WAAW,QASrB;IAFG,6BAA0D;IAK9D,6BASC;IAED;;;OAGG;IACH,oBAFW,MAAM,QAchB;IAGD;;;;;;;;OAQG;IACH,mBAPW,MAAM,WACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAwBhB;IAED;;;OAGG;IACH,uBAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,4BAHW,MAAM,GACJ,MAAM,CAQlB;IAGD;;;OAGG;IACH,oBAFW,MAAM,EAAE,QAgFlB;IAED;;;;;OAKG;IACH,sBAYC;IAED;;OAEG;IACH,cAsEC;CACJ"}
+{"version":3,"file":"StaticR2Tree.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/2d/r-tree/StaticR2Tree.js"],"names":[],"mappings":"AAoEA;;;GAGG;AACH;IAEI;;;OAGG;IACH,sBAAc;IAEd;;;;OAIG;IACH,+BAAc;IAEd;;;;OAIG;IACH,4BAAwB;IAExB;;;;OAIG;IACH,0BAAsB;IAOtB;;;OAGG;IACH,kBAFW,WAAW,QASrB;IAFG,6BAA0D;IAK9D,6BASC;IAED;;;OAGG;IACH,oBAFW,MAAM,QAchB;IAGD;;;;;;;;OAQG;IACH,mBAPW,MAAM,WACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAwBhB;IAED;;;OAGG;IACH,uBAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,4BAHW,MAAM,GACJ,MAAM,CAQlB;IAGD;;;OAGG;IACH,oBAFW,MAAM,EAAE,QAgFlB;IAED;;;;;OAKG;IACH,sBAYC;IAED;;OAEG;IACH,cAuEC;CACJ"}

package/src/core/geom/2d/r-tree/StaticR2Tree.js

@@ -28,8 +28,8 @@ function build_normalized_morton_2d(
 
     const x0 = data[address];
     const y0 = data[address + 1];
-    const x1 = data[address + 3];
-    const y1 = data[address + 4];
+    const x1 = data[address + 2];
+    const y1 = data[address + 3];
 
     const cx = (x0 + x1) * 0.5;
     const cy = (y0 + y1) * 0.5;
@@ -345,8 +345,9 @@ export class StaticR2Tree {
                     float32, leaf_offset_1
                 );
             } else if (leaf_index_0 < node_count_leaf) {
-                // only left child node is valid
-                array_copy(float32, leaf_offset_0, float32, offset, 6);
+                // only left child node is valid; a 2D box is 4 floats [x0,y0,x1,y1] (copying 6 would spill into
+                // the following node's data)
+                array_copy(float32, leaf_offset_0, float32, offset, 4);
             } else {
                 //initialize to 0-size box same position as previous node
                 copy_box_zero_size(this.__data_float32, offset, (offset - BINARY_NODE_SIZE));

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

@@ -1 +1 @@
-{"version":3,"file":"aabb3_detailed_volume_intersection.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/aabb/aabb3_detailed_volume_intersection.js"],"names":[],"mappings":"AA8CA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,gEAbW,MAAM,EAAE,sBACR,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,cAEN,MAAM,UADN,MAAM,EAAE,eAER,MAAM,GACJ,MAAM,CAqOlB"}
+{"version":3,"file":"aabb3_detailed_volume_intersection.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/aabb/aabb3_detailed_volume_intersection.js"],"names":[],"mappings":"AA8CA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,gEAbW,MAAM,EAAE,sBACR,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,cAEN,MAAM,UADN,MAAM,EAAE,eAER,MAAM,GACJ,MAAM,CAyOlB"}

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

@@ -242,47 +242,51 @@ export function aabb3_detailed_volume_intersection(
         const aabb_plane_nz = scratch_aabb_planes[aabb_plane_address + 2];
         const aabb_plane_constant = scratch_aabb_planes[aabb_plane_address + 3];
 
-        for (let frustum_plane_index = 0; frustum_plane_index < 4; frustum_plane_index++) {
+        // The 4 frustum side-edges are each the intersection of one +/-x plane (index 0 or 1) with one +/-y
+        // plane (index 2 or 3). The previous (i, (i+2)%4) pairing produced only 2 of those 4 edges, each twice
+        // (missing the +x/-y and -x/+y edges), so AABB-vs-edge contact points on those edges were never found.
+        // Enumerate all four non-parallel pairs explicitly.
+        for (let pa = 0; pa < 2; pa++) {
 
-            const plane_bit_mask = 1 << frustum_plane_index;
-
-            if ((plane_mask & plane_bit_mask) === 0) {
-                // non-intersecting plane, ignore
+            if ((plane_mask & (1 << pa)) === 0) {
                 continue;
             }
 
-            const cp_0 = frustum_plane_index * 4;
-
-            const next_orthogonal_plane_index = (frustum_plane_index + 2) % 4;
-            const cp_1 = next_orthogonal_plane_index * 4;
+            const cp_0 = pa * 4;
 
-            const intersection_exists = plane3_compute_convex_3_plane_intersection(
-                scratch_v3_array, 0,
-                aabb_plane_nx, aabb_plane_ny, aabb_plane_nz, aabb_plane_constant,
-                planes[cp_0], planes[cp_0 + 1], planes[cp_0 + 2], planes[cp_0 + 3],
-                planes[cp_1], planes[cp_1 + 1], planes[cp_1 + 2], planes[cp_1 + 3]
-            );
+            for (let pb = 2; pb < 4; pb++) {
 
-            if (intersection_exists) {
+                if ((plane_mask & (1 << pb)) === 0) {
+                    continue;
+                }
 
-                const intersection_point_x = scratch_v3_array[0];
-                const intersection_point_y = scratch_v3_array[1];
-                const intersection_point_z = scratch_v3_array[2];
+                const cp_1 = pb * 4;
 
-                const point_within_box = !(
-                    (intersection_point_x + EPSILON) < x0 || (intersection_point_x - EPSILON) > x1
-                    || (intersection_point_y + EPSILON) < y0 || (intersection_point_y - EPSILON) > y1
-                    || (intersection_point_z + EPSILON) < z0 || (intersection_point_z - EPSILON) > z1
+                const intersection_exists = plane3_compute_convex_3_plane_intersection(
+                    scratch_v3_array, 0,
+                    aabb_plane_nx, aabb_plane_ny, aabb_plane_nz, aabb_plane_constant,
+                    planes[cp_0], planes[cp_0 + 1], planes[cp_0 + 2], planes[cp_0 + 3],
+                    planes[cp_1], planes[cp_1 + 1], planes[cp_1 + 2], planes[cp_1 + 3]
                 );
 
-                if (point_within_box) {
-                    // point is within the AABB bounds
+                if (intersection_exists) {
+
+                    const intersection_point_x = scratch_v3_array[0];
+                    const intersection_point_y = scratch_v3_array[1];
+                    const intersection_point_z = scratch_v3_array[2];
 
-                    // ThreeClippingPlaneComputingBVHVisitor.DEBUG_POINTS_2.send3(scratch_v3.x, scratch_v3.y, scratch_v3.z);
+                    const point_within_box = !(
+                        (intersection_point_x + EPSILON) < x0 || (intersection_point_x - EPSILON) > x1
+                        || (intersection_point_y + EPSILON) < y0 || (intersection_point_y - EPSILON) > y1
+                        || (intersection_point_z + EPSILON) < z0 || (intersection_point_z - EPSILON) > z1
+                    );
 
-                    destination[destination_cursor++] = intersection_point_x;
-                    destination[destination_cursor++] = intersection_point_y;
-                    destination[destination_cursor++] = intersection_point_z;
+                    if (point_within_box) {
+                        // point is within the AABB bounds
+                        destination[destination_cursor++] = intersection_point_x;
+                        destination[destination_cursor++] = intersection_point_y;
+                        destination[destination_cursor++] = intersection_point_z;
+                    }
                 }
             }
         }

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

@@ -1 +1 @@
-{"version":3,"file":"aabb3_near_distance_to_intersection_ray_segment.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/aabb/aabb3_near_distance_to_intersection_ray_segment.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;GAiBG;AACH,oEAhBW,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,MAAM,CAgDlB"}
+{"version":3,"file":"aabb3_near_distance_to_intersection_ray_segment.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/aabb/aabb3_near_distance_to_intersection_ray_segment.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;GAiBG;AACH,oEAhBW,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,MAAM,CAkDlB"}

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

@@ -59,7 +59,9 @@ export function aabb3_near_distance_to_intersection_ray_segment(
     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);
 
-    if (t_box_min > t_box_max) {
+    // Negated `<=` so a NaN bound (ray parallel to a slab with the origin exactly on that slab's face) is
+    // treated as a miss; `t_box_min > t_box_max` would be false for NaN and leak NaN out as the result.
+    if (!(t_box_min <= t_box_max)) {
         // signal a miss
         return Infinity;
     }

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

@@ -1 +1 @@
-{"version":3,"file":"aabb3_signed_distance_to_aabb3.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/aabb/aabb3_signed_distance_to_aabb3.js"],"names":[],"mappings":"AAAA,+KA2BC"}
+{"version":3,"file":"aabb3_signed_distance_to_aabb3.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/aabb/aabb3_signed_distance_to_aabb3.js"],"names":[],"mappings":"AAAA,+KA8BC"}

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

@@ -16,13 +16,16 @@ export function aabb3_signed_distance_to_aabb3(
     const dy = Math.max(yp0, yp1);
     const dz = Math.max(zp0, zp1);
 
-    //straight-line distance
-    let distance = Math.sqrt(dx * dx + dy * dy + dz * dz);
-
     if (dx < 0 && dy < 0 && dz < 0) {
-        //penetration
-        return -distance;
-    } else {
-        return distance;
+        //penetration: boxes overlap on every axis
+        return -Math.sqrt(dx * dx + dy * dy + dz * dz);
     }
+
+    // Separated on at least one axis. Only the positive (separating) components contribute to the gap;
+    // a negative component means the boxes already overlap on that axis and must not inflate the distance.
+    const sx = dx > 0 ? dx : 0;
+    const sy = dy > 0 ? dy : 0;
+    const sz = dz > 0 ? dz : 0;
+
+    return Math.sqrt(sx * sx + sy * sy + sz * sz);
 }

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

@@ -1 +1 @@
-{"version":3,"file":"aabb3_transformed_compute_plane_side.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/aabb/aabb3_transformed_compute_plane_side.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;GAeG;AACH,yDAbW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,kBACN,MAAM,kBACN,MAAM,kBACN,MAAM,gBACN,MAAM,oBACN,MAAM,EAAE,GAAC,YAAY,GACnB,MAAM,CA8ClB"}
+{"version":3,"file":"aabb3_transformed_compute_plane_side.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/aabb/aabb3_transformed_compute_plane_side.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;GAeG;AACH,yDAbW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,kBACN,MAAM,kBACN,MAAM,kBACN,MAAM,gBACN,MAAM,oBACN,MAAM,EAAE,GAAC,YAAY,GACnB,MAAM,CAmElB"}

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

@@ -1,8 +1,8 @@
 import {v3_distance_above_plane} from "../../vec3/v3_distance_above_plane.js";
 import {aabb3_build_corners} from "./aabb3_build_corners.js";
-import {aabb3_matrix4_project_by_corners} from "./aabb3_matrix4_project_by_corners.js";
 
 const scratch_corners = new Float32Array(24);
+const scratch_transformed = new Float32Array(24);
 
 /**
  * Figure out which side of a plane an Axis-Aligned Bounding Box lies, after applying transform matrix to it
@@ -33,19 +33,40 @@ export function aabb3_transformed_compute_plane_side(
         x0, y0, z0, x1, y1, z1
     );
 
-    aabb3_matrix4_project_by_corners(
-        scratch_corners,
-        scratch_corners,
-        transform_matrix
-    );
+    // Transform all 8 corners by the matrix, keeping each transformed corner. We intentionally do NOT use
+    // aabb3_matrix4_project_by_corners here: it re-bounds the transformed corners down to a single 6-value
+    // AABB written back into the same buffer, which would leave 6 of the 8 classification slots holding stale,
+    // untransformed corners.
+    const m0 = transform_matrix[0], m1 = transform_matrix[1], m2 = transform_matrix[2], m3 = transform_matrix[3];
+    const m4 = transform_matrix[4], m5 = transform_matrix[5], m6 = transform_matrix[6], m7 = transform_matrix[7];
+    const m8 = transform_matrix[8], m9 = transform_matrix[9], m10 = transform_matrix[10], m11 = transform_matrix[11];
+    const m12 = transform_matrix[12], m13 = transform_matrix[13], m14 = transform_matrix[14], m15 = transform_matrix[15];
+
+    for (let i = 0; i < 24; i += 3) {
+        const _x = scratch_corners[i];
+        const _y = scratch_corners[i + 1];
+        const _z = scratch_corners[i + 2];
+
+        const t_x = m0 * _x + m4 * _y + m8 * _z + m12;
+        const t_y = m1 * _x + m5 * _y + m9 * _z + m13;
+        const t_z = m2 * _x + m6 * _y + m10 * _z + m14;
+        const t_w = m3 * _x + m7 * _y + m11 * _z + m15;
+
+        // perspective divide; harmless (w === 1) for the affine model matrices this is called with.
+        const d = 1 / t_w;
+
+        scratch_transformed[i] = t_x * d;
+        scratch_transformed[i + 1] = t_y * d;
+        scratch_transformed[i + 2] = t_z * d;
+    }
 
     let has_above = false, has_below = false;
 
     for (let i = 0; i < 8; i++) {
         const i3 = i * 3;
-        const x = scratch_corners[i3];
-        const y = scratch_corners[i3 + 1];
-        const z = scratch_corners[i3 + 2];
+        const x = scratch_transformed[i3];
+        const y = scratch_transformed[i3 + 1];
+        const z = scratch_transformed[i3 + 2];
 
         if (v3_distance_above_plane(x, y, z, plane_normal_x, plane_normal_y, plane_normal_z, plane_offset)) {
             has_above = true;

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

@@ -1,5 +1,5 @@
-import {min2} from "../../../math/min2.js";
-import {max2} from "../../../math/max2.js";
+import { max2 } from "../../../math/max2.js";
+import { min2 } from "../../../math/min2.js";
 
 /**
  * Multidimensional axis-aligned bounding box calculation
@@ -27,7 +27,7 @@ export function compute_aabb_from_points(
 
     for (i = 0; i < input_count; i++) {
 
-        const offset_0 = input_count + i * d;
+        const offset_0 = input_offset + i * d;
 
         for (j = 0; j < d; j++) {
             const v = input[offset_0 + j];

package/src/core/geom/3d/box/box3_raycast.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Ray ↔ box intersection in the box's LOCAL frame: an axis-aligned box centred
+ * at the origin spanning `[−hx,hx] × [−hy,hy] × [−hz,hz]` — the canonical pose of
+ * `BoxShape3D` (an oriented box transformed into its own frame). Slab method.
+ * Returns the hit distance `t` and writes the outward unit FACE normal into
+ * `outNormal[outOffset .. outOffset+2]`.
+ *
+ * Conventions (shared with {@link sphere_raycast} / {@link capsule_raycast}):
+ *  - the ray direction is assumed UNIT length, so `t` is a true distance;
+ *  - the first crossing at or after the origin within `tMax` is returned; a ray
+ *    starting INSIDE the box returns its exit face;
+ *  - on a miss the function returns `Infinity` and leaves `outNormal` untouched.
+ *
+ * Distinct from {@link aabb3_raycast}, which takes an arbitrary min/max box and
+ * returns a boolean + hit POSITION + a quantized normal. This one serves the
+ * raycast/narrowphase need: the entry distance, the EXACT face normal, `tMax`
+ * clamping, and origin-inside handling.
+ *
+ * @param {Float64Array|number[]} outNormal destination for the unit normal
+ * @param {number} outOffset offset into `outNormal` (3 floats are written)
+ * @param {number} ox ray origin x (local)
+ * @param {number} oy ray origin y (local)
+ * @param {number} oz ray origin z (local)
+ * @param {number} dx ray direction x (local, unit)
+ * @param {number} dy ray direction y (local, unit)
+ * @param {number} dz ray direction z (local, unit)
+ * @param {number} tMax maximum ray distance
+ * @param {number} hx half-extent along x
+ * @param {number} hy half-extent along y
+ * @param {number} hz half-extent along z
+ * @returns {number} hit distance `t`, or `Infinity` on a miss
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function box3_raycast(outNormal: Float64Array | number[], outOffset: number, ox: number, oy: number, oz: number, dx: number, dy: number, dz: number, tMax: number, hx: number, hy: number, hz: number): number;
+//# sourceMappingURL=box3_raycast.d.ts.map

package/src/core/geom/3d/box/box3_raycast.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"box3_raycast.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/box/box3_raycast.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,wCAjBW,YAAY,GAAC,MAAM,EAAE,aACrB,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,MAAM,CAkDlB"}

package/src/core/geom/3d/box/box3_raycast.js

@@ -0,0 +1,81 @@
+/**
+ * Ray ↔ box intersection in the box's LOCAL frame: an axis-aligned box centred
+ * at the origin spanning `[−hx,hx] × [−hy,hy] × [−hz,hz]` — the canonical pose of
+ * `BoxShape3D` (an oriented box transformed into its own frame). Slab method.
+ * Returns the hit distance `t` and writes the outward unit FACE normal into
+ * `outNormal[outOffset .. outOffset+2]`.
+ *
+ * Conventions (shared with {@link sphere_raycast} / {@link capsule_raycast}):
+ *  - the ray direction is assumed UNIT length, so `t` is a true distance;
+ *  - the first crossing at or after the origin within `tMax` is returned; a ray
+ *    starting INSIDE the box returns its exit face;
+ *  - on a miss the function returns `Infinity` and leaves `outNormal` untouched.
+ *
+ * Distinct from {@link aabb3_raycast}, which takes an arbitrary min/max box and
+ * returns a boolean + hit POSITION + a quantized normal. This one serves the
+ * raycast/narrowphase need: the entry distance, the EXACT face normal, `tMax`
+ * clamping, and origin-inside handling.
+ *
+ * @param {Float64Array|number[]} outNormal destination for the unit normal
+ * @param {number} outOffset offset into `outNormal` (3 floats are written)
+ * @param {number} ox ray origin x (local)
+ * @param {number} oy ray origin y (local)
+ * @param {number} oz ray origin z (local)
+ * @param {number} dx ray direction x (local, unit)
+ * @param {number} dy ray direction y (local, unit)
+ * @param {number} dz ray direction z (local, unit)
+ * @param {number} tMax maximum ray distance
+ * @param {number} hx half-extent along x
+ * @param {number} hy half-extent along y
+ * @param {number} hz half-extent along z
+ * @returns {number} hit distance `t`, or `Infinity` on a miss
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function box3_raycast(outNormal, outOffset, ox, oy, oz, dx, dy, dz, tMax, hx, hy, hz) {
+    let tmin = -Infinity, tmax = Infinity;
+    let enterAxis = 0, enterSign = 0, exitAxis = 0, exitSign = 0;
+
+    // X slab.
+    if (dx !== 0) {
+        const inv = 1 / dx;
+        let tn = (-hx - ox) * inv, tf = (hx - ox) * inv, nsign = -1;
+        if (tn > tf) { const tmp = tn; tn = tf; tf = tmp; nsign = 1; }
+        if (tn > tmin) { tmin = tn; enterAxis = 0; enterSign = nsign; }
+        if (tf < tmax) { tmax = tf; exitAxis = 0; exitSign = -nsign; }
+    } else if (ox < -hx || ox > hx) {
+        return Infinity;
+    }
+    // Y slab.
+    if (dy !== 0) {
+        const inv = 1 / dy;
+        let tn = (-hy - oy) * inv, tf = (hy - oy) * inv, nsign = -1;
+        if (tn > tf) { const tmp = tn; tn = tf; tf = tmp; nsign = 1; }
+        if (tn > tmin) { tmin = tn; enterAxis = 1; enterSign = nsign; }
+        if (tf < tmax) { tmax = tf; exitAxis = 1; exitSign = -nsign; }
+    } else if (oy < -hy || oy > hy) {
+        return Infinity;
+    }
+    // Z slab.
+    if (dz !== 0) {
+        const inv = 1 / dz;
+        let tn = (-hz - oz) * inv, tf = (hz - oz) * inv, nsign = -1;
+        if (tn > tf) { const tmp = tn; tn = tf; tf = tmp; nsign = 1; }
+        if (tn > tmin) { tmin = tn; enterAxis = 2; enterSign = nsign; }
+        if (tf < tmax) { tmax = tf; exitAxis = 2; exitSign = -nsign; }
+    } else if (oz < -hz || oz > hz) {
+        return Infinity;
+    }
+
+    if (tmax < tmin || tmax < 0) return Infinity;
+
+    let t, axis, sign;
+    if (tmin >= 0) { t = tmin; axis = enterAxis; sign = enterSign; }
+    else { t = tmax; axis = exitAxis; sign = exitSign; } // origin inside the box
+
+    if (t > tMax) return Infinity;
+    outNormal[outOffset] = 0; outNormal[outOffset + 1] = 0; outNormal[outOffset + 2] = 0;
+    outNormal[outOffset + axis] = sign;
+    return t;
+}

package/src/core/geom/3d/capsule/capsule_raycast.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Ray ↔ capsule intersection in the capsule's LOCAL frame: a capsule along the
+ * local Y axis — a cylinder of radius `r` over `y ∈ [−hh, hh]` capped by
+ * hemispheres of radius `r` at `(0, ±hh, 0)` — the canonical pose of
+ * `CapsuleShape3D` (`hh = height / 2`). Tests the infinite cylinder (clamped to
+ * the segment) and the two cap spheres, taking the nearest valid crossing.
+ * Returns the hit distance `t` and writes the outward unit surface normal into
+ * `outNormal[outOffset .. outOffset+2]`.
+ *
+ * Conventions (shared with {@link sphere_raycast} / {@link box3_raycast}):
+ *  - the ray direction is assumed UNIT length, so `t` is a true distance;
+ *  - the first surface crossing at or after the origin within `tMax` is returned;
+ *  - on a miss the function returns `Infinity` and leaves `outNormal` untouched.
+ *
+ * No prior ray-vs-capsule primitive existed in `core/geom`; this fills that gap
+ * (useful for picking, sensors, and the raycast narrowphase).
+ *
+ * @param {Float64Array|number[]} outNormal destination for the unit normal
+ * @param {number} outOffset offset into `outNormal` (3 floats are written)
+ * @param {number} ox ray origin x (local)
+ * @param {number} oy ray origin y (local)
+ * @param {number} oz ray origin z (local)
+ * @param {number} dx ray direction x (local, unit)
+ * @param {number} dy ray direction y (local, unit)
+ * @param {number} dz ray direction z (local, unit)
+ * @param {number} tMax maximum ray distance
+ * @param {number} r capsule radius
+ * @param {number} hh half-height of the cylindrical section (`height / 2`)
+ * @returns {number} hit distance `t`, or `Infinity` on a miss
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function capsule_raycast(outNormal: Float64Array | number[], outOffset: number, ox: number, oy: number, oz: number, dx: number, dy: number, dz: number, tMax: number, r: number, hh: number): number;
+//# sourceMappingURL=capsule_raycast.d.ts.map

package/src/core/geom/3d/capsule/capsule_raycast.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"capsule_raycast.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/capsule/capsule_raycast.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,2CAhBW,YAAY,GAAC,MAAM,EAAE,aACrB,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QACN,MAAM,KACN,MAAM,MACN,MAAM,GACJ,MAAM,CAgElB"}

package/src/core/geom/3d/capsule/capsule_raycast.js

@@ -0,0 +1,93 @@
+/**
+ * Ray ↔ capsule intersection in the capsule's LOCAL frame: a capsule along the
+ * local Y axis — a cylinder of radius `r` over `y ∈ [−hh, hh]` capped by
+ * hemispheres of radius `r` at `(0, ±hh, 0)` — the canonical pose of
+ * `CapsuleShape3D` (`hh = height / 2`). Tests the infinite cylinder (clamped to
+ * the segment) and the two cap spheres, taking the nearest valid crossing.
+ * Returns the hit distance `t` and writes the outward unit surface normal into
+ * `outNormal[outOffset .. outOffset+2]`.
+ *
+ * Conventions (shared with {@link sphere_raycast} / {@link box3_raycast}):
+ *  - the ray direction is assumed UNIT length, so `t` is a true distance;
+ *  - the first surface crossing at or after the origin within `tMax` is returned;
+ *  - on a miss the function returns `Infinity` and leaves `outNormal` untouched.
+ *
+ * No prior ray-vs-capsule primitive existed in `core/geom`; this fills that gap
+ * (useful for picking, sensors, and the raycast narrowphase).
+ *
+ * @param {Float64Array|number[]} outNormal destination for the unit normal
+ * @param {number} outOffset offset into `outNormal` (3 floats are written)
+ * @param {number} ox ray origin x (local)
+ * @param {number} oy ray origin y (local)
+ * @param {number} oz ray origin z (local)
+ * @param {number} dx ray direction x (local, unit)
+ * @param {number} dy ray direction y (local, unit)
+ * @param {number} dz ray direction z (local, unit)
+ * @param {number} tMax maximum ray distance
+ * @param {number} r capsule radius
+ * @param {number} hh half-height of the cylindrical section (`height / 2`)
+ * @returns {number} hit distance `t`, or `Infinity` on a miss
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function capsule_raycast(outNormal, outOffset, ox, oy, oz, dx, dy, dz, tMax, r, hh) {
+    let best = Infinity;
+    let nx = 0, ny = 0, nz = 0;
+    const r2 = r * r;
+    const inv_r = 1 / r;
+
+    // --- Cylinder side (infinite cylinder about Y, projected to XZ). ---
+    const a = dx * dx + dz * dz;
+    if (a > 1e-12) {
+        const b = ox * dx + oz * dz;
+        const c = ox * ox + oz * oz - r2;
+        const disc = b * b - a * c;
+        if (disc >= 0) {
+            const sq = Math.sqrt(disc);
+            const inv_a = 1 / a;
+            // Both roots; the smaller non-negative one whose hit lies on the
+            // cylindrical section is the side contact.
+            const roots = (-b - sq) * inv_a;
+            const rootf = (-b + sq) * inv_a;
+            for (let i = 0; i < 2; i++) {
+                const t = i === 0 ? roots : rootf;
+                if (t < 0 || t >= best || t > tMax) continue;
+                const y = oy + dy * t;
+                if (y < -hh || y > hh) continue; // off the cylinder, onto a cap
+                best = t;
+                const px = ox + dx * t, pz = oz + dz * t;
+                nx = px * inv_r; ny = 0; nz = pz * inv_r;
+                break; // roots is the nearer; if it qualified we're done
+            }
+        }
+    }
+
+    // --- Cap spheres at (0, ±hh, 0), each valid only on its outer hemisphere. ---
+    for (let cap = 0; cap < 2; cap++) {
+        const cy = cap === 0 ? hh : -hh;
+        const oyc = oy - cy;
+        const bb = ox * dx + oyc * dy + oz * dz;
+        const cc = ox * ox + oyc * oyc + oz * oz - r2;
+        const disc = bb * bb - cc;
+        if (disc < 0) continue;
+        const sq = Math.sqrt(disc);
+        const tn = -bb - sq, tf = -bb + sq;
+        for (let i = 0; i < 2; i++) {
+            const t = i === 0 ? tn : tf;
+            if (t < 0 || t >= best || t > tMax) continue;
+            const hy = oy + dy * t;
+            // Only the hemisphere beyond the segment end belongs to this cap.
+            if (cap === 0 ? hy < hh : hy > -hh) continue;
+            best = t;
+            nx = (ox + dx * t) * inv_r;
+            ny = (hy - cy) * inv_r;
+            nz = (oz + dz * t) * inv_r;
+            break;
+        }
+    }
+
+    if (best === Infinity) return Infinity;
+    outNormal[outOffset] = nx; outNormal[outOffset + 1] = ny; outNormal[outOffset + 2] = nz;
+    return best;
+}

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

@@ -1 +1 @@
-{"version":3,"file":"compute_bounding_cone_of_2_cones.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/cone/compute_bounding_cone_of_2_cones.js"],"names":[],"mappings":"AAiBA;;;;;GAKG;AACH,mGAqEC"}
+{"version":3,"file":"compute_bounding_cone_of_2_cones.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/cone/compute_bounding_cone_of_2_cones.js"],"names":[],"mappings":"AAiBA;;;;;GAKG;AACH,mGAyEC"}

package/src/core/geom/3d/cone/compute_bounding_cone_of_2_cones.js

@@ -51,6 +51,10 @@ export function compute_bounding_cone_of_2_cones(result, a, b) {
 
     // compute normal vectors bounding each cone in the common plane
     tangent.crossVectors(a.direction, b.direction);
+    // the cross of two unit directions has length sin(angle); quat3_createFromAxisAngle needs a unit axis,
+    // otherwise the cone edges are rotated by the wrong angle. The parallel/anti-parallel degenerate cases
+    // (|tangent| == 0) are already excluded by the containment early-returns above.
+    tangent.normalize();
 
     const a_half_angle = a.angle;
 

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

@@ -72,7 +72,7 @@ export function frustum3_computeNearestPointToPoint(result, planes, target_x, ta
         const plane_0_index = scratch_outer_planes[0];
         const plane_0 = planes[plane_0_index];
         // point lies outside exactly one plane
-        plane3_project_point(result, target_x, target_y, target_z, plane_0.normal.z, plane_0.normal.y, plane_0.normal.z, plane_0.constant);
+        plane3_project_point(result, target_x, target_y, target_z, plane_0.normal.x, plane_0.normal.y, plane_0.normal.z, plane_0.constant);
     } else if (outside_plane_count === 2) {
         // outside two planes, nearest point lies on the intersection line of two planes
 

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

@@ -1 +1 @@
-{"version":3,"file":"line3_compute_segment_point_distance_eikonal.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/line/line3_compute_segment_point_distance_eikonal.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,iEAbW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,MAAM,CAiFlB"}
+{"version":3,"file":"line3_compute_segment_point_distance_eikonal.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/line/line3_compute_segment_point_distance_eikonal.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,iEAbW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,MAAM,CAkFlB"}

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

@@ -82,8 +82,9 @@ export function line3_compute_segment_point_distance_eikonal(
     const coef = p / det_sqrt;
     const s = x_local - y * coef; // Intersection with x-axis
 
-    if (s > 0) {
-        // 5. Valid Eikonal Update
+    if (s > 0 && s < L) {
+        // 5. Valid Eikonal Update — the characteristic foot must land strictly inside the segment (0, L);
+        // an s >= L means the geodesic actually wraps via the far vertex, handled by the fallback below.
         return u0 + (p * x_local + y * det_sqrt) / q;
     } else {
         // 6. Fallback (The path comes strictly from one of the vertices)

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

@@ -1 +1 @@
-{"version":3,"file":"decompose_matrix_4_array.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/mat4/decompose_matrix_4_array.js"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,+CALW,MAAM,EAAE,yDA6DlB"}
+{"version":3,"file":"decompose_matrix_4_array.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/mat4/decompose_matrix_4_array.js"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,+CALW,MAAM,EAAE,yDAuElB"}

package/src/core/geom/3d/mat4/decompose_matrix_4_array.js

@@ -26,9 +26,19 @@ export function decompose_matrix_4_array(mat4, position, rotation, scale) {
 
     const scale_z = v3_length(m31, m32, m33);
 
+    // If the upper-left 3x3 has a negative determinant the matrix encodes a reflection; fold that sign into
+    // one scale axis (matching three.js, which negates scale.x) so the extracted rotation is a proper rotation
+    // rather than a mirror (which __setFromRotationMatrix would decode incorrectly).
+    const det =
+        m11 * (m22 * m33 - m23 * m32)
+        - m12 * (m21 * m33 - m23 * m31)
+        + m13 * (m21 * m32 - m22 * m31);
+
+    const signed_scale_x = det < 0 ? -scale_x : scale_x;
+
     // extract rotation matrix
     // take care of potential division by 0 when scale is 0. Result is inexact, but we get don't break the system at least
-    const is1 = scale_x !== 0 ? 1 / scale_x : 1e7;
+    const is1 = signed_scale_x !== 0 ? 1 / signed_scale_x : 1e7;
     const is2 = scale_y !== 0 ? 1 / scale_y : 1e7;
     const is3 = scale_z !== 0 ? 1 / scale_z : 1e7;
 
@@ -53,7 +63,7 @@ export function decompose_matrix_4_array(mat4, position, rotation, scale) {
     );
 
     scale.set(
-        scale_x,
+        signed_scale_x,
         scale_y,
         scale_z
     );

package/src/core/geom/3d/mat4/eulerAnglesFromMatrix.js

@@ -62,7 +62,7 @@ export function eulerAnglesFromMatrix(
     if (a0 === a2) {
         output[0] = atan2(coeff(m4, j, i), coeff(m4, k, i));
 
-        if ((odd && output[0] < 0) || ((~odd) && output[0] > 0)) {
+        if ((odd && output[0] < 0) || ((!odd) && output[0] > 0)) {
             if (output[0] > 0) {
                 output[0] -= Math.PI;
             } else {
@@ -96,7 +96,7 @@ export function eulerAnglesFromMatrix(
 
         const c2 = v2_length(coeff(m4, i, i), coeff(m4, i, j));
 
-        if ((odd && output[0] < 0) || ((~odd) && output[0] > 0)) {
+        if ((odd && output[0] < 0) || ((!odd) && output[0] > 0)) {
             if (output[0] > 0) {
                 output[0] -= Math.PI;
             } else {

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

@@ -7,5 +7,5 @@
  * @param {number[]|Float32Array} b
  * @returns {number[]|Float32Array} `out` parameter
  */
-export function m4_multiply_alphatensor(out: number[] | Float32Array, a: number[] | Float32Array, b: number[] | Float32Array): number[] | Float32Array;
+export function m4_multiply_alphatensor(out: number[] | Float32Array, a_in: any, b_in: any): number[] | Float32Array;
 //# sourceMappingURL=m4_multiply_alphatensor.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"m4_multiply_alphatensor.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/mat4/m4_multiply_alphatensor.js"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,6CALW,MAAM,EAAE,GAAC,YAAY,KACrB,MAAM,EAAE,GAAC,YAAY,KACrB,MAAM,EAAE,GAAC,YAAY,GACnB,MAAM,EAAE,GAAC,YAAY,CA8IjC"}
+{"version":3,"file":"m4_multiply_alphatensor.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/mat4/m4_multiply_alphatensor.js"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,6CALW,MAAM,EAAE,GAAC,YAAY,yBAGnB,MAAM,EAAE,GAAC,YAAY,CAoJjC"}