@woosh/meep-engine 2.163.10 → 2.164.0

package/src/engine/network/sim/Snapshotter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Snapshotter.d.ts","sourceRoot":"","sources":["../../../../../src/engine/network/sim/Snapshotter.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAEH;;;;;;;;;;GAUG;AACH,iGARW;IACV,MAAU,eAAe;IACzB,KAAS,yBAAyB;IAClC,UAAc,uBAAuB;IACrC,kBAAsB,8BAA8B;IACpD,WAAe,gBAAoB,MAAM,KAAG,IAAI,KAAG,IAAI,CAAC;CACrD,QAkDH;AAED;;;;;;;;;;;GAWG;AACH,iGARW;IACV,MAAU,eAAe;IACzB,UAAc,EAAE,MAAM,CAAC;IACvB,KAAS,yBAAyB;IAClC,UAAc,uBAAuB;IACrC,kBAAsB,8BAA8B;CACjD,QAqCH;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,6GARW;IACV,MAAU,eAAe;IACzB,UAAc,EAAE,MAAM,CAAC;IACvB,KAAS,yBAAyB;IAClC,UAAc,uBAAuB;IACrC,kBAAsB,8BAA8B;CACjD,QAyCH"}
+{"version":3,"file":"Snapshotter.d.ts","sourceRoot":"","sources":["../../../../../src/engine/network/sim/Snapshotter.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAEH;;;;;;;;;;GAUG;AACH,iGARW;IACV,MAAU,eAAe;IACzB,KAAS,yBAAyB;IAClC,UAAc,uBAAuB;IACrC,kBAAsB,8BAA8B;IACpD,WAAe,gBAAoB,MAAM,KAAG,IAAI,KAAG,IAAI,CAAC;CACrD,QAkDH;AAED;;;;;;;;;;;GAWG;AACH,iGARW;IACV,MAAU,eAAe;IACzB,UAAc,EAAE,MAAM,CAAC;IACvB,KAAS,yBAAyB;IAClC,UAAc,uBAAuB;IACrC,kBAAsB,8BAA8B;CACjD,QA6CH;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,6GARW;IACV,MAAU,eAAe;IACzB,UAAc,EAAE,MAAM,CAAC;IACvB,KAAS,yBAAyB;IAClC,UAAc,uBAAuB;IACrC,kBAAsB,8BAA8B;CACjD,QAgDH"}

package/src/engine/network/sim/Snapshotter.js

@@ -1,4 +1,5 @@
 import { assert } from "../../../core/assert.js";
+import { MalformedPacketError } from "../core/MalformedPacketError.js";
 
 /**
  * Initial-sync state stream generator.
@@ -109,6 +110,11 @@ export function snapshotter_apply({ buffer, buffer_end, world, slot_table, compo
     const entity_count = buffer.readUintVar();
 
     for (let i = 0; i < entity_count; i++) {
+        // Untrusted entity_count: stop creating entities once the declared
+        // stream is consumed rather than reading stale/out-of-bounds bytes.
+        if (buffer.position >= buffer_end) {
+            throw new MalformedPacketError(`snapshotter_apply: entity_count ${entity_count} overruns snapshot (entity ${i})`);
+        }
         const network_id = buffer.readUintVar();
         const component_count = buffer.readUint8();
 
@@ -118,6 +124,9 @@ export function snapshotter_apply({ buffer, buffer_end, world, slot_table, compo
         for (let j = 0; j < component_count; j++) {
             const type_id = buffer.readUint8();
             const payload_len = buffer.readUint32();
+            if (buffer.position + payload_len > buffer_end) {
+                throw new MalformedPacketError(`snapshotter_apply: component payload of ${payload_len}B overruns snapshot (network_id ${network_id})`);
+            }
 
             const klass = component_registry.class_of(type_id);
             const adapter = component_registry.adapter_for_id(type_id);
@@ -136,7 +145,7 @@ export function snapshotter_apply({ buffer, buffer_end, world, slot_table, compo
         }
 
         if (buffer.position > buffer_end) {
-            throw new Error(`snapshotter_apply: read past buffer_end at network_id ${network_id}`);
+            throw new MalformedPacketError(`snapshotter_apply: read past buffer_end at network_id ${network_id}`);
         }
     }
 }
@@ -169,6 +178,10 @@ export function snapshotter_apply_to_existing({ buffer, buffer_end, world, slot_
     const entity_count = buffer.readUintVar();
 
     for (let i = 0; i < entity_count; i++) {
+        // Untrusted entity_count: stop once the declared stream is consumed.
+        if (buffer.position >= buffer_end) {
+            throw new MalformedPacketError(`snapshotter_apply_to_existing: entity_count ${entity_count} overruns snapshot (entity ${i})`);
+        }
         const network_id = buffer.readUintVar();
         const component_count = buffer.readUint8();
 
@@ -177,6 +190,9 @@ export function snapshotter_apply_to_existing({ buffer, buffer_end, world, slot_
         for (let j = 0; j < component_count; j++) {
             const type_id = buffer.readUint8();
             const payload_len = buffer.readUint32();
+            if (buffer.position + payload_len > buffer_end) {
+                throw new MalformedPacketError(`snapshotter_apply_to_existing: component payload of ${payload_len}B overruns snapshot (network_id ${network_id})`);
+            }
 
             const klass = component_registry.class_of(type_id);
             const adapter = component_registry.adapter_for_id(type_id);
@@ -200,7 +216,7 @@ export function snapshotter_apply_to_existing({ buffer, buffer_end, world, slot_
         }
 
         if (buffer.position > buffer_end) {
-            throw new Error(`snapshotter_apply_to_existing: read past buffer_end at network_id ${network_id}`);
+            throw new MalformedPacketError(`snapshotter_apply_to_existing: read past buffer_end at network_id ${network_id}`);
         }
     }
 }

package/src/engine/network/transport/Channel.d.ts

@@ -2,13 +2,24 @@ export class Channel {
     /**
      * @param {{
      *   transport: { send(bytes: Uint8Array, length: number): void, onReceive: Signal },
+     *   max_in_flight?: number,
      * }} options
+     *   `max_in_flight` hard-caps the number of unacked outgoing seqs. It exists
+     *   to keep the in-flight span well below the seq16 half-range (32768): once
+     *   an unacked seq falls more than half-range behind the newest sent, the
+     *   signed `seq16_distance` used for loss detection wraps and the entry can
+     *   neither be acked nor declared lost — a permanent leak (and a downstream
+     *   `seq_to_frame_end` leak in the orchestrator). Capping in-flight makes
+     *   that lap impossible. Default 1024 ≫ any realistic in-flight window
+     *   (RTT × send-rate) yet ≪ 32768. Only reached under a sustained one-way
+     *   stall, where eviction-as-lost is the correct verdict anyway.
      */
-    constructor({ transport }: {
+    constructor({ transport, max_in_flight }: {
         transport: {
             send(bytes: Uint8Array, length: number): void;
             onReceive: Signal;
         };
+        max_in_flight?: number;
     });
     /**
      * @type {{ send(bytes: Uint8Array, length: number): void, onReceive: Signal }}

package/src/engine/network/transport/Channel.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Channel.d.ts","sourceRoot":"","sources":["../../../../../src/engine/network/transport/Channel.js"],"names":[],"mappings":"AA6CA;IAUI;;;;OAIG;IACH;;wBAH8B,UAAU,UAAU,MAAM,GAAG,IAAI;uBAAa,MAAM;;OA0EjF;IAnEG;;OAEG;IACH;oBAFwB,UAAU,UAAU,MAAM,GAAG,IAAI;mBAAa,MAAM;MAElD;IA6C1B;;;OAGG;IACH,eAFU,MAAM,CAEiB;IAEjC;;;OAGG;IACH,cAFU,MAAM,CAEgB;IAEhC;;;;;OAKG;IACH,WAFU,MAAM,CAEa;IAGjC;;;;;;OAMG;IACH,cAJW,UAAU,UACV,MAAM,GACJ,MAAM,CAgClB;IAED;;;OAGG;IACH,iBAFa,MAAM,CAIlB;IAED;;;OAGG;IACH,uBAFa,MAAM,CAIlB;IAED;;;;;OAKG;IACH,mCAFW,MAAM,QAIhB;IA+ED;;;;;;;OAOG;IACH,gBAEC;;CAiBJ;mBA7SkB,uCAAuC"}
+{"version":3,"file":"Channel.d.ts","sourceRoot":"","sources":["../../../../../src/engine/network/transport/Channel.js"],"names":[],"mappings":"AA6CA;IAWI;;;;;;;;;;;;;;OAcG;IACH;;wBAb8B,UAAU,UAAU,MAAM,GAAG,IAAI;uBAAa,MAAM;;wBAC7D,MAAM;OAwF1B;IAnEG;;OAEG;IACH;oBAFwB,UAAU,UAAU,MAAM,GAAG,IAAI;mBAAa,MAAM;MAElD;IA6C1B;;;OAGG;IACH,eAFU,MAAM,CAEiB;IAEjC;;;OAGG;IACH,cAFU,MAAM,CAEgB;IAEhC;;;;;OAKG;IACH,WAFU,MAAM,CAEa;IAGjC;;;;;;OAMG;IACH,cAJW,UAAU,UACV,MAAM,GACJ,MAAM,CAiDlB;IAED;;;OAGG;IACH,iBAFa,MAAM,CAIlB;IAED;;;OAGG;IACH,uBAFa,MAAM,CAIlB;IAED;;;;;OAKG;IACH,mCAFW,MAAM,QAIhB;IA+ED;;;;;;;OAOG;IACH,gBAEC;;CAiBJ;mBA9UkB,uCAAuC"}

package/src/engine/network/transport/Channel.js

@@ -51,16 +51,32 @@ export class Channel {
     #send_buffer;
     #send_view;
     #lost_scratch;
+    #max_in_flight;
 
 
     /**
      * @param {{
      *   transport: { send(bytes: Uint8Array, length: number): void, onReceive: Signal },
+     *   max_in_flight?: number,
      * }} options
+     *   `max_in_flight` hard-caps the number of unacked outgoing seqs. It exists
+     *   to keep the in-flight span well below the seq16 half-range (32768): once
+     *   an unacked seq falls more than half-range behind the newest sent, the
+     *   signed `seq16_distance` used for loss detection wraps and the entry can
+     *   neither be acked nor declared lost — a permanent leak (and a downstream
+     *   `seq_to_frame_end` leak in the orchestrator). Capping in-flight makes
+     *   that lap impossible. Default 1024 ≫ any realistic in-flight window
+     *   (RTT × send-rate) yet ≪ 32768. Only reached under a sustained one-way
+     *   stall, where eviction-as-lost is the correct verdict anyway.
      */
-    constructor({ transport }) {
+    constructor({ transport, max_in_flight = 1024 }) {
         assert.ok(transport && typeof transport.send === 'function', 'transport must implement send()');
         assert.ok(transport.onReceive, 'transport must expose onReceive signal');
+        assert.isPositiveInteger(max_in_flight, 'max_in_flight');
+        assert.lessThan(max_in_flight, SEQ16_HALF_RANGE, 'max_in_flight must stay below the seq16 half-range');
+
+        /** @type {number} @private */
+        this.#max_in_flight = max_in_flight;
 
         /**
          * @type {{ send(bytes: Uint8Array, length: number): void, onReceive: Signal }}
@@ -167,6 +183,23 @@ export class Channel {
         this.transport.send(this.#send_buffer, total_size);
         this.#unacked_outgoing.add(seq);
 
+        // Enforce the in-flight bound. `#unacked_outgoing` is a Set, so its
+        // iteration order is insertion order = send order = ascending seq; the
+        // first entry is therefore the oldest unacked. When we exceed the cap
+        // (only possible under a sustained one-way stall where acks have
+        // stopped advancing the window), evict the oldest as lost. This keeps
+        // the in-flight span below the seq16 half-range so loss detection can't
+        // alias, and frees the entry (and its orchestrator-side mapping, via
+        // the onPacketLost handler) instead of leaking it. In a stall the
+        // oldest is an action-stream packet, whose loss handler does not
+        // retransmit; reliable-command retransmits are independently bounded by
+        // ReliableCommandPipeline.max_unacked (≪ this cap), so this cannot loop.
+        if (this.#unacked_outgoing.size > this.#max_in_flight) {
+            const oldest = this.#unacked_outgoing.values().next().value;
+            this.#unacked_outgoing.delete(oldest);
+            this.onPacketLost.send1(oldest);
+        }
+
         return seq;
     }
 

package/src/engine/physics/broadphase/generate_pairs.js

@@ -1,4 +1,4 @@
-import { bvh_query_user_data_overlaps_aabb } from "../../../core/bvh2/bvh3/query/bvh_query_user_data_overlaps_aabb.js";
+import { bvh_query_user_data_intersects_aabb } from "../../../core/bvh2/bvh3/query/bvh_query_user_data_intersects_aabb.js";
 import { body_id_index, pack_body_id } from "../body/BodyStorage.js";
 
 const scratch_aabb = new Float64Array(6);
@@ -81,7 +81,7 @@ export function generate_pairs(
             // queries → converges in one resize, amortised to zero).
             let n;
             for (;;) {
-                n = bvh_query_user_data_overlaps_aabb(
+                n = bvh_query_user_data_intersects_aabb(
                     candidates, 0,
                     dynamic_bvh,
                     scratch_aabb
@@ -107,7 +107,7 @@ export function generate_pairs(
 
             // Dynamic ↔ Static. Same grow-and-retry as the dynamic loop.
             for (;;) {
-                n = bvh_query_user_data_overlaps_aabb(
+                n = bvh_query_user_data_intersects_aabb(
                     candidates, 0,
                     static_bvh,
                     scratch_aabb

package/src/engine/physics/constraint/solve_constraints.js

@@ -1,6 +1,6 @@
 import { quat3_multiply } from "../../../core/geom/3d/quaternion/quat3_multiply.js";
 import { quat3_to_matrix3 } from "../../../core/geom/3d/quaternion/quat3_to_matrix3.js";
-import { v3_quat3_apply } from "../../../core/geom/vec3/v3_quat3_apply.js";
+import { v3_quaternion_apply } from "../../../core/geom/vec3/v3_quaternion_apply.js";
 import { body_id_index } from "../body/BodyStorage.js";
 import {
     SBS_AV_X,
@@ -590,7 +590,7 @@ export function solve_joints(joints, system, dt_sub, iters, reverse) {
 
         // World anchor A and its lever arm rA = R_A · localAnchorA.
         const la = joint.localAnchorA;
-        v3_quat3_apply(scratch_anchor, 0, la.x, la.y, la.z,
+        v3_quaternion_apply(scratch_anchor, 0, la.x, la.y, la.z,
             trA.rotation[0], trA.rotation[1], trA.rotation[2], trA.rotation[3]);
         const rAx = scratch_anchor[0], rAy = scratch_anchor[1], rAz = scratch_anchor[2];
         const anchorAx = trA.position.x + rAx;
@@ -605,7 +605,7 @@ export function solve_joints(joints, system, dt_sub, iters, reverse) {
         if (to_world) {
             anchorBx = lb.x; anchorBy = lb.y; anchorBz = lb.z;
         } else {
-            v3_quat3_apply(scratch_anchor, 0, lb.x, lb.y, lb.z,
+            v3_quaternion_apply(scratch_anchor, 0, lb.x, lb.y, lb.z,
                 trB.rotation[0], trB.rotation[1], trB.rotation[2], trB.rotation[3]);
             rBx = scratch_anchor[0]; rBy = scratch_anchor[1]; rBz = scratch_anchor[2];
             anchorBx = trB.position.x + rBx;

package/src/engine/physics/ecs/PhysicsSystem.js

@@ -1,7 +1,7 @@
 import { assert } from "../../../core/assert.js";
 import { BinaryBuffer } from "../../../core/binary/BinaryBuffer.js";
 import { BVH } from "../../../core/bvh2/bvh3/BVH.js";
-import { bvh_query_user_data_overlaps_aabb } from "../../../core/bvh2/bvh3/query/bvh_query_user_data_overlaps_aabb.js";
+import { bvh_query_user_data_intersects_aabb } from "../../../core/bvh2/bvh3/query/bvh_query_user_data_intersects_aabb.js";
 import { returnTrue } from "../../../core/function/returnTrue.js";
 import { aabb3_transform_oriented } from "../../../core/geom/3d/aabb/aabb3_transform_oriented.js";
 import Vector3 from "../../../core/geom/Vector3.js";
@@ -582,7 +582,7 @@ export class PhysicsSystem extends System {
 
         let n;
         for (;;) {
-            n = bvh_query_user_data_overlaps_aabb(scratch_wake_candidates, 0, this.dynamicBvh, scratch_world_aabb);
+            n = bvh_query_user_data_intersects_aabb(scratch_wake_candidates, 0, this.dynamicBvh, scratch_world_aabb);
             if (n <= scratch_wake_candidates.length) break;
             // TRUE count returned, overflow writes dropped — grow and re-query.
             scratch_wake_candidates = new Uint32Array(Math.max(n, scratch_wake_candidates.length * 2));

package/src/engine/physics/fluid/ecs/FluidObstacleSystem.d.ts

@@ -64,11 +64,11 @@ export class FluidObstacleSystem extends System<any, any, any, any, any> {
     /**
      * @param {FluidComponent} fluid
      */
-    static "__#144@#refresh_masks"(fluid: FluidComponent): void;
+    static "__#148@#refresh_masks"(fluid: FluidComponent): void;
     /**
      * @param {FluidComponent} fluid
      */
-    static "__#144@#clear_field"(fluid: FluidComponent): void;
+    static "__#148@#clear_field"(fluid: FluidComponent): void;
     /**
      * Mark every cell of `fluid` whose centre lies within `inflation` of the
      * posed shape as solid. Iteration is clipped to the shape's world AABB
@@ -80,7 +80,7 @@ export class FluidObstacleSystem extends System<any, any, any, any, any> {
      * @param {number} inflation       world-units SDF threshold
      * @param {Float64Array} point     length-3 scratch
      */
-    static "__#144@#voxelize"(fluid: FluidComponent, posed: PosedShape3D, aabb: Float64Array, inflation: number, point: Float64Array): void;
+    static "__#148@#voxelize"(fluid: FluidComponent, posed: PosedShape3D, aabb: Float64Array, inflation: number, point: Float64Array): void;
     /**
      * Write the obstacle's translation velocity onto every face of every cell
      * it voxelized — the moving-wall boundary condition. Runs AFTER the mask
@@ -100,7 +100,7 @@ export class FluidObstacleSystem extends System<any, any, any, any, any> {
      * @param {number} wvy
      * @param {number} wvz
      */
-    static "__#144@#stamp_wall_velocity"(fluid: FluidComponent, posed: PosedShape3D, aabb: Float64Array, inflation: number, point: Float64Array, wvx: number, wvy: number, wvz: number): void;
+    static "__#148@#stamp_wall_velocity"(fluid: FluidComponent, posed: PosedShape3D, aabb: Float64Array, inflation: number, point: Float64Array, wvx: number, wvy: number, wvz: number): void;
     constructor();
     dependencies: (typeof FluidObstacle)[];
     components_used: (ResourceAccessSpecification<typeof RigidBody> | ResourceAccessSpecification<typeof Collider> | ResourceAccessSpecification<typeof Transform> | ResourceAccessSpecification<typeof FluidComponent> | ResourceAccessSpecification<typeof FluidObstacle>)[];

package/src/engine/physics/fluid/ecs/FluidSystem.d.ts

@@ -38,7 +38,7 @@ export class FluidSystem extends System<any, any, any, any, any> {
      * @param {FluidEffectorsComponent} effectors_component
      * @param {Transform} transform
      */
-    static "__#143@#sync_effectors_from_transform"(effectors_component: FluidEffectorsComponent, transform: Transform): void;
+    static "__#147@#sync_effectors_from_transform"(effectors_component: FluidEffectorsComponent, transform: Transform): void;
     /**
      * Visitor for the (FluidComponent, Transform) traversal — keeps the field's
      * grid origin locked to a cell-aligned position near the transform.
@@ -61,7 +61,7 @@ export class FluidSystem extends System<any, any, any, any, any> {
      * @param {FluidComponent} component
      * @param {Transform} transform
      */
-    static "__#143@#reanchor_field"(component: FluidComponent, transform: Transform): void;
+    static "__#147@#reanchor_field"(component: FluidComponent, transform: Transform): void;
     /**
      * Write the world-to-grid affine for a FluidComponent into `out`. Axis-aligned,
      * uniform-scale, so the matrix is sparse:
@@ -76,7 +76,7 @@ export class FluidSystem extends System<any, any, any, any, any> {
      * @param {Float32Array} out  length-16
      * @param {FluidComponent} component
      */
-    static "__#143@#build_world_to_grid"(out: Float32Array, component: FluidComponent): void;
+    static "__#147@#build_world_to_grid"(out: Float32Array, component: FluidComponent): void;
     constructor();
     dependencies: (typeof FluidComponent)[];
     /**

package/src/engine/physics/inverse_kinematics/two_joint_ik.js

@@ -1,5 +1,5 @@
 import Quaternion from "../../../core/geom/Quaternion.js";
-import { v3_compute_interior_angle } from "../../../core/geom/vec3/v3_compute_interior_angle.js";
+import { v3_interior_angle } from "../../../core/geom/vec3/v3_interior_angle.js";
 import Vector3 from "../../../core/geom/Vector3.js";
 import { clamp } from "../../../core/math/clamp.js";
 
@@ -52,9 +52,9 @@ export function two_joint_ik(
     const lat = clamp(t.distanceTo(a), eps, maximum_extension);
 
     //compute current interior angles
-    const ac_ab_0 = v3_compute_interior_angle(c, a, b);
-    const ba_bc_0 = v3_compute_interior_angle(a, b, c);
-    const ac_at_0 = v3_compute_interior_angle(c, a, t);
+    const ac_ab_0 = v3_interior_angle(c, a, b);
+    const ba_bc_0 = v3_interior_angle(a, b, c);
+    const ac_at_0 = v3_interior_angle(c, a, t);
 
     // Using the cosine rule to compute desired interior angles
     const length_at_sqr = lat * lat;

package/src/engine/physics/narrowphase/box_box_manifold.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"box_box_manifold.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/narrowphase/box_box_manifold.js"],"names":[],"mappings":"AA6JA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,sCAvBW,MAAM,EAAE,GAAC,YAAY,MACrB,MAAM,MACN,MAAM,MACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,GACJ,OAAO,CA8enB;AA9lBD;;;GAGG;AACH,iCAFU,MAAM,CAEoD"}
+{"version":3,"file":"box_box_manifold.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/narrowphase/box_box_manifold.js"],"names":[],"mappings":"AA2JA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,sCAvBW,MAAM,EAAE,GAAC,YAAY,MACrB,MAAM,MACN,MAAM,MACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,GACJ,OAAO,CA8enB;AA9lBD;;;GAGG;AACH,iCAFU,MAAM,CAEoD"}

package/src/engine/physics/narrowphase/box_box_manifold.js

@@ -1,6 +1,4 @@
-import {
-    line3_closest_points_segment_segment
-} from "../../../core/geom/3d/line/line3_closest_points_segment_segment.js";
+import { line3_compute_segment_segment_closest_points } from "../../../core/geom/3d/line/line3_compute_segment_segment_closest_points.js";
 import { quat3_to_matrix3 } from "../../../core/geom/3d/quaternion/quat3_to_matrix3.js";
 import { polygon2_clip_axis_halfplane } from "../../../core/geom/2d/polygon/polygon2_clip_axis_halfplane.js";
 import { reduce_manifold_contacts } from "./reduce_manifold_contacts.js";
@@ -89,7 +87,7 @@ const clipped_uv_out = new Float64Array(8 * 2);
 // Stride 4 per candidate: x, y, z, depth.
 const candidates = new Float64Array(8 * 4);
 
-// Output of line3_closest_points_segment_segment for the edge-cross
+// Output of line3_compute_segment_segment_closest_points for the edge-cross
 // SAT-winner path: (s, t) parameters along the two edges.
 const scratch_edge_st = new Float64Array(2);
 
@@ -250,7 +248,7 @@ export function box_box_manifold(
     //   2. Among box A's 4 parallel edges along axis i, pick the one
     //      whose corner is most in the −n direction (closest to B).
     //   3. Same for box B with +n direction.
-    //   4. `line3_closest_points_segment_segment` returns (s, t)
+    //   4. `line3_compute_segment_segment_closest_points` returns (s, t)
     //      parameters; reconstruct the world contact on each edge.
     if (best_source >= 6) {
         const ax_src = best_source - 6;
@@ -338,7 +336,7 @@ export function box_box_manifold(
         const edge_b_p2_y = corner_b_cy + edge_b_dy * edge_b_half;
         const edge_b_p2_z = corner_b_cz + edge_b_dz * edge_b_half;
 
-        line3_closest_points_segment_segment(
+        line3_compute_segment_segment_closest_points(
             scratch_edge_st,
             edge_a_p1_x, edge_a_p1_y, edge_a_p1_z, edge_a_p2_x, edge_a_p2_y, edge_a_p2_z,
             edge_b_p1_x, edge_b_p1_y, edge_b_p1_z, edge_b_p2_x, edge_b_p2_y, edge_b_p2_z

package/src/engine/physics/narrowphase/box_triangle_contact.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"box_triangle_contact.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/narrowphase/box_triangle_contact.js"],"names":[],"mappings":"AAuOA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,0CAtBW,MAAM,EAAE,GAAC,YAAY,OACrB,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,OAAO,CAuGnB;AApRD;;;GAGG;AACH,sCAFU,MAAM,CAEyD"}
+{"version":3,"file":"box_triangle_contact.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/narrowphase/box_triangle_contact.js"],"names":[],"mappings":"AAqOA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,0CAtBW,MAAM,EAAE,GAAC,YAAY,OACrB,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,OAAO,CAuGnB;AApRD;;;GAGG;AACH,sCAFU,MAAM,CAEyD"}

package/src/engine/physics/narrowphase/box_triangle_contact.js

@@ -1,6 +1,4 @@
-import {
-    line3_closest_points_segment_segment
-} from "../../../core/geom/3d/line/line3_closest_points_segment_segment.js";
+import { line3_compute_segment_segment_closest_points } from "../../../core/geom/3d/line/line3_compute_segment_segment_closest_points.js";
 import { quat3_to_matrix3 } from "../../../core/geom/3d/quaternion/quat3_to_matrix3.js";
 import { polygon2_clip_axis_halfplane } from "../../../core/geom/2d/polygon/polygon2_clip_axis_halfplane.js";
 import { reduce_manifold_contacts } from "./reduce_manifold_contacts.js";
@@ -37,7 +35,7 @@ import { box3_projected_half_extent } from "../../../core/geom/3d/box/box3_proje
  *
  *     c. Edge-cross axis (sources 4..12) — single contact at the
  *        closest pair of points on the relevant box edge and triangle
- *        edge (via {@link line3_closest_points_segment_segment}).
+ *        edge (via {@link line3_compute_segment_segment_closest_points}).
  *
  *  3. Reduce surviving contacts to at most {@link MAX_CONTACTS} by
  *     deepest-first then perimeter expansion.
@@ -774,7 +772,7 @@ function emit_triangle_face_manifold(
  *      (the +/- of the other two box half-extents pushing to the
  *      "near" corner determined by the SAT-axis sign).
  *   2. Construct the triangle edge as the segment.
- *   3. Closest-pair via `line3_closest_points_segment_segment`.
+ *   3. Closest-pair via `line3_compute_segment_segment_closest_points`.
  *   4. Contact = midpoint, depth = best_overlap.
  */
 /**
@@ -873,7 +871,7 @@ function emit_edge_cross_contact(
     }
 
     // Closest points on the two segments.
-    line3_closest_points_segment_segment(
+    line3_compute_segment_segment_closest_points(
         closest_pair_st,
         box_p1x, box_p1y, box_p1z, box_p2x, box_p2y, box_p2z,
         tri_p1x, tri_p1y, tri_p1z, tri_p2x, tri_p2y, tri_p2z

package/src/engine/physics/narrowphase/capsule_contacts.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"capsule_contacts.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/narrowphase/capsule_contacts.js"],"names":[],"mappings":"AA4BA;;;;;;;;;;;;;;;GAeG;AACH,2CAVW,MAAM,EAAE,GAAC,YAAY,MACrB,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,eACN,MAAM,QAOhB;AAID;;;;;;;;;;;;;;;;;;GAkBG;AACH,4CAhBW,MAAM,EAAE,GAAC,YAAY,QACrB,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,YACN,MAAM,YACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,YACN,MAAM,GACJ,OAAO,CA6CnB;AAMD;;;;;GAKG;AACH,6CAHW,MAAM,EAAE,GAAC,YAAY,yNACnB,OAAO,CAuEnB;AA8BD;;;;;;;;;GASG;AACH,oDAHW,MAAM,EAAE,GAAC,YAAY,yNACnB,MAAM,CAoHlB;AASD;;;;;;;;;;;;;GAaG;AACH,yCAHW,MAAM,EAAE,GAAC,YAAY,4NACnB,OAAO,CAqGnB;AAyCD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,gDAtBW,YAAY,QACZ,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,YACN,MAAM,YACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,GACJ,MAAM,CAsElB;AAzaD;;;;;;;;GAQG;AACH,6CAFU,MAAM,CAEiC;AAEjD;;;;GAIG;AACH,2CAFU,MAAM,CAE8B;AAsQ9C;;;;;;;;;;GAUG;AACH,yCAFU,MAAM,CAE6B;AAE7C;;;;;GAKG;AACH,uCAFU,MAAM,CAE0B"}
+{"version":3,"file":"capsule_contacts.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/narrowphase/capsule_contacts.js"],"names":[],"mappings":"AA6BA;;;;;;;;;;;;;;;GAeG;AACH,2CAVW,MAAM,EAAE,GAAC,YAAY,MACrB,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,eACN,MAAM,QAOhB;AAID;;;;;;;;;;;;;;;;;;GAkBG;AACH,4CAhBW,MAAM,EAAE,GAAC,YAAY,QACrB,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,YACN,MAAM,YACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,YACN,MAAM,GACJ,OAAO,CA6CnB;AAMD;;;;;GAKG;AACH,6CAHW,MAAM,EAAE,GAAC,YAAY,yNACnB,OAAO,CAuEnB;AA8BD;;;;;;;;;GASG;AACH,oDAHW,MAAM,EAAE,GAAC,YAAY,yNACnB,MAAM,CAoHlB;AASD;;;;;;;;;;;;;GAaG;AACH,yCAHW,MAAM,EAAE,GAAC,YAAY,4NACnB,OAAO,CA6FnB;AAyCD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,gDAtBW,YAAY,QACZ,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,YACN,MAAM,YACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,GACJ,MAAM,CAsElB;AAjaD;;;;;;;;GAQG;AACH,6CAFU,MAAM,CAEiC;AAEjD;;;;GAIG;AACH,2CAFU,MAAM,CAE8B;AA8P9C;;;;;;;;;;GAUG;AACH,yCAFU,MAAM,CAE6B;AAE7C;;;;;GAKG;AACH,uCAFU,MAAM,CAE0B"}

package/src/engine/physics/narrowphase/capsule_contacts.js

@@ -1,7 +1,8 @@
-import { line3_closest_points_segment_segment } from "../../../core/geom/3d/line/line3_closest_points_segment_segment.js";
-import { line3_compute_segment_nearest_point_to_point_t } from "../../../core/geom/3d/line/line3_compute_segment_nearest_point_to_point_t.js";
-import { v3_quat3_apply } from "../../../core/geom/vec3/v3_quat3_apply.js";
-import { v3_quat3_apply_inverse } from "../../../core/geom/vec3/v3_quat3_apply_inverse.js";
+import { line3_compute_segment_segment_closest_points } from "../../../core/geom/3d/line/line3_compute_segment_segment_closest_points.js";
+import { line3_compute_segment_closest_point_t } from "../../../core/geom/3d/line/line3_compute_segment_closest_point_t.js";
+import { line3_compute_segment_closest_point_to_aabb3_t } from "../../../core/geom/3d/line/line3_compute_segment_closest_point_to_aabb3_t.js";
+import { v3_quaternion_apply } from "../../../core/geom/vec3/v3_quaternion_apply.js";
+import { v3_quaternion_apply_inverse } from "../../../core/geom/vec3/v3_quaternion_apply_inverse.js";
 import { sphere_box_contact } from "./sphere_box_contact.js";
 
 /**
@@ -43,8 +44,8 @@ const scratch_seg = new Float64Array(6);
  * @param {number} half_height
  */
 export function capsule_world_segment(out, cx, cy, cz, qx, qy, qz, qw, half_height) {
-    v3_quat3_apply(out, 0, 0, -half_height, 0, qx, qy, qz, qw);
-    v3_quat3_apply(out, 3, 0,  half_height, 0, qx, qy, qz, qw);
+    v3_quaternion_apply(out, 0, 0, -half_height, 0, qx, qy, qz, qw);
+    v3_quaternion_apply(out, 3, 0,  half_height, 0, qx, qy, qz, qw);
     out[0] += cx; out[1] += cy; out[2] += cz;
     out[3] += cx; out[4] += cy; out[5] += cz;
 }
@@ -79,7 +80,7 @@ export function capsule_sphere_contact(
     const sax = scratch_seg[0], say = scratch_seg[1], saz = scratch_seg[2];
     const sbx = scratch_seg[3], sby = scratch_seg[4], sbz = scratch_seg[5];
 
-    const t = line3_compute_segment_nearest_point_to_point_t(sax, say, saz, sbx, sby, sbz, b_cx, b_cy, b_cz);
+    const t = line3_compute_segment_closest_point_t(sax, say, saz, sbx, sby, sbz, b_cx, b_cy, b_cz);
 
     const px = sax + (sbx - sax) * t;
     const py = say + (sby - say) * t;
@@ -138,7 +139,7 @@ export function capsule_capsule_contact(
     const b0x = scratch_seg_b[0], b0y = scratch_seg_b[1], b0z = scratch_seg_b[2];
     const b1x = scratch_seg_b[3], b1y = scratch_seg_b[4], b1z = scratch_seg_b[5];
 
-    line3_closest_points_segment_segment(
+    line3_compute_segment_segment_closest_points(
         scratch_st,
         a0x, a0y, a0z, a1x, a1y, a1z,
         b0x, b0y, b0z, b1x, b1y, b1z
@@ -383,33 +384,25 @@ export function capsule_box_contact(
     // World → box-local: subtract box centre, then rotate by conjugate of box quat.
     const w_a0x = scratch_seg[0] - b_cx, w_a0y = scratch_seg[1] - b_cy, w_a0z = scratch_seg[2] - b_cz;
     const w_a1x = scratch_seg[3] - b_cx, w_a1y = scratch_seg[4] - b_cy, w_a1z = scratch_seg[5] - b_cz;
-    v3_quat3_apply_inverse(scratch_a0_local, 0, w_a0x, w_a0y, w_a0z, b_qx, b_qy, b_qz, b_qw);
-    v3_quat3_apply_inverse(scratch_a1_local, 0, w_a1x, w_a1y, w_a1z, b_qx, b_qy, b_qz, b_qw);
+    v3_quaternion_apply_inverse(scratch_a0_local, 0, w_a0x, w_a0y, w_a0z, b_qx, b_qy, b_qz, b_qw);
+    v3_quaternion_apply_inverse(scratch_a1_local, 0, w_a1x, w_a1y, w_a1z, b_qx, b_qy, b_qz, b_qw);
 
     const a0lx = scratch_a0_local[0], a0ly = scratch_a0_local[1], a0lz = scratch_a0_local[2];
     const a1lx = scratch_a1_local[0], a1ly = scratch_a1_local[1], a1lz = scratch_a1_local[2];
 
-    // Fixed-point iteration: start with t at the closest point to the box centre.
-    let t = line3_compute_segment_nearest_point_to_point_t(a0lx, a0ly, a0lz, a1lx, a1ly, a1lz, 0, 0, 0);
-    let plx = a0lx + (a1lx - a0lx) * t;
-    let ply = a0ly + (a1ly - a0ly) * t;
-    let plz = a0lz + (a1lz - a0lz) * t;
-
-    for (let iter = 0; iter < 2; iter++) {
-        // Clamp current segment point to the box → closest box-surface point.
-        const qlx = plx < -b_hx ? -b_hx : (plx > b_hx ? b_hx : plx);
-        const qly = ply < -b_hy ? -b_hy : (ply > b_hy ? b_hy : ply);
-        const qlz = plz < -b_hz ? -b_hz : (plz > b_hz ? b_hz : plz);
-
-        // Re-find closest segment point to that box point.
-        t = line3_compute_segment_nearest_point_to_point_t(
-            a0lx, a0ly, a0lz, a1lx, a1ly, a1lz,
-            qlx, qly, qlz
-        );
-        plx = a0lx + (a1lx - a0lx) * t;
-        ply = a0ly + (a1ly - a0ly) * t;
-        plz = a0lz + (a1lz - a0lz) * t;
-    }
+    // Exact closest point on the capsule segment to the box-local AABB [−h, h].
+    // Replaces a 2-iteration alternating projection (project onto segment, clamp
+    // into box, repeat) that converged too slowly for capsules near-parallel to
+    // a box face/edge — overestimating the segment-vs-box distance, which
+    // under-detected contacts (~0.85% of random configs missed) and mis-placed
+    // depth/normal on many more. See core/geom/3d/gjk/GJK_REVIEW_NOTES.md.
+    const t = line3_compute_segment_closest_point_to_aabb3_t(
+        a0lx, a0ly, a0lz, a1lx, a1ly, a1lz,
+        -b_hx, -b_hy, -b_hz, b_hx, b_hy, b_hz
+    );
+    const plx = a0lx + (a1lx - a0lx) * t;
+    const ply = a0ly + (a1ly - a0ly) * t;
+    const plz = a0lz + (a1lz - a0lz) * t;
 
     // Final box-side point. `let` because the interior branch snaps it onto
     // the chosen face — for an inside segment point the clamp is an identity.
@@ -453,18 +446,18 @@ export function capsule_box_contact(
     }
 
     // Normal (box → capsule axis point) into world.
-    v3_quat3_apply(out, 0, nlx, nly, nlz, b_qx, b_qy, b_qz, b_qw);
+    v3_quaternion_apply(out, 0, nlx, nly, nlz, b_qx, b_qy, b_qz, b_qw);
     const nx = out[0], ny = out[1], nz = out[2];
     out[3] = a_radius - dist;
 
     // Capsule-side contact: world segment point pushed back by radius.
-    v3_quat3_apply(out, 4, plx, ply, plz, b_qx, b_qy, b_qz, b_qw);
+    v3_quaternion_apply(out, 4, plx, ply, plz, b_qx, b_qy, b_qz, b_qw);
     out[4] += b_cx - nx * a_radius;
     out[5] += b_cy - ny * a_radius;
     out[6] += b_cz - nz * a_radius;
 
     // Box-side contact: world projection of the box-surface point.
-    v3_quat3_apply(out, 7, qlx, qly, qlz, b_qx, b_qy, b_qz, b_qw);
+    v3_quaternion_apply(out, 7, qlx, qly, qlz, b_qx, b_qy, b_qz, b_qw);
     out[7] += b_cx;
     out[8] += b_cy;
     out[9] += b_cz;

package/src/engine/physics/narrowphase/capsule_triangle_contact.js

@@ -1,5 +1,5 @@
-import { computeTriangleClosestPointToPointBarycentric } from "../../../core/geom/3d/triangle/computeTriangleClosestPointToPointBarycentric.js";
-import { line3_closest_points_segment_segment } from "../../../core/geom/3d/line/line3_closest_points_segment_segment.js";
+import { tri3_closest_point_barycentric } from "../../../core/geom/3d/triangle/tri3_closest_point_barycentric.js";
+import { line3_compute_segment_segment_closest_points } from "../../../core/geom/3d/line/line3_compute_segment_segment_closest_points.js";
 import { capsule_world_segment } from "./capsule_contacts.js";
 import { sphere_triangle_contact } from "./sphere_triangle_contact.js";
 
@@ -102,7 +102,7 @@ let g_ct_best_tx = 0, g_ct_best_ty = 0, g_ct_best_tz = 0;
 
 /** Segment-vs-triangle-edge closest pair; folds into the g_ct_best_* minimum. */
 function test_edge(e_p1x, e_p1y, e_p1z, e_p2x, e_p2y, e_p2z) {
-    line3_closest_points_segment_segment(
+    line3_compute_segment_segment_closest_points(
         scratch_pair_st,
         g_ct_p1x, g_ct_p1y, g_ct_p1z, g_ct_p2x, g_ct_p2y, g_ct_p2z,
         e_p1x, e_p1y, e_p1z, e_p2x, e_p2y, e_p2z
@@ -134,10 +134,10 @@ function test_edge(e_p1x, e_p1y, e_p1z, e_p2x, e_p2y, e_p2z) {
  *  - Case 0: segment crosses triangle's plane inside the face
  *    → distance 0; both points coincide on the face.
  *  - Cases 1, 2: each segment endpoint vs its closest point on the
- *    triangle (via {@link computeTriangleClosestPointToPointBarycentric}).
+ *    triangle (via {@link tri3_closest_point_barycentric}).
  *    Subsumes the "endpoint vs triangle vertex / edge / face" cases.
  *  - Cases 3, 4, 5: segment vs each of the triangle's 3 edges, via
- *    {@link line3_closest_points_segment_segment}. Covers the
+ *    {@link line3_compute_segment_segment_closest_points}. Covers the
  *    "segment interior closest to triangle edge" case that the
  *    endpoint queries miss.
  *
@@ -176,7 +176,7 @@ function segment_triangle_closest(
             // closest point on the triangle. If the closest point equals
             // the input (within INSIDE_TRIANGLE_EPS_SQR), the intersection
             // is inside the face.
-            computeTriangleClosestPointToPointBarycentric(
+            tri3_closest_point_barycentric(
                 scratch_bary, 0,
                 ix, iy, iz,
                 ax, ay, az,
@@ -199,7 +199,7 @@ function segment_triangle_closest(
     }
 
     // --- Case 1: P1 vs closest-on-triangle -----------------------------------
-    computeTriangleClosestPointToPointBarycentric(
+    tri3_closest_point_barycentric(
         scratch_bary, 0,
         p1x, p1y, p1z,
         ax, ay, az,
@@ -223,7 +223,7 @@ function segment_triangle_closest(
     }
 
     // --- Case 2: P2 vs closest-on-triangle -----------------------------------
-    computeTriangleClosestPointToPointBarycentric(
+    tri3_closest_point_barycentric(
         scratch_bary, 0,
         p2x, p2y, p2z,
         ax, ay, az,

package/src/engine/physics/narrowphase/compute_penetration.js

@@ -1,8 +1,8 @@
 import { aabb3_transform_oriented } from "../../../core/geom/3d/aabb/aabb3_transform_oriented.js";
-import { v3_quat3_apply } from "../../../core/geom/vec3/v3_quat3_apply.js";
+import { v3_quaternion_apply } from "../../../core/geom/vec3/v3_quaternion_apply.js";
 import { aabb3_transform_oriented_inverse } from "../../../core/geom/3d/aabb/aabb3_transform_oriented_inverse.js";
 import { decompose_to_triangles } from "./decomposition/decompose_to_triangles.js";
-import { computeTriangleClosestPointToPointBarycentric } from "../../../core/geom/3d/triangle/computeTriangleClosestPointToPointBarycentric.js";
+import { tri3_closest_point_barycentric } from "../../../core/geom/3d/triangle/tri3_closest_point_barycentric.js";
 import { TRIANGLE_FLOAT_STRIDE } from "./decomposition/triangle_buffer_layout.js";
 import { deepest_pair_penetration } from "./narrowphase_step.js";
 import { PosedShape3D } from "../../../core/geom/3d/shape/PosedShape3D.js";
@@ -271,7 +271,7 @@ function concave_recovery_penetration(
         fnx_l *= fn_inv; fny_l *= fn_inv; fnz_l *= fn_inv;
 
         // Rotate face normal to world via the concave body's quaternion.
-        v3_quat3_apply(scratch_rot, 0, fnx_l, fny_l, fnz_l, cqx, cqy, cqz, cqw);
+        v3_quaternion_apply(scratch_rot, 0, fnx_l, fny_l, fnz_l, cqx, cqy, cqz, cqw);
         const fnx_w = scratch_rot[0];
         const fny_w = scratch_rot[1];
         const fnz_w = scratch_rot[2];
@@ -280,7 +280,7 @@ function concave_recovery_penetration(
         const cent_lx = (ax + bx + cx_v) / 3;
         const cent_ly = (ay + by + cy_v) / 3;
         const cent_lz = (az + bz + cz_v) / 3;
-        v3_quat3_apply(scratch_rot, 0, cent_lx, cent_ly, cent_lz, cqx, cqy, cqz, cqw);
+        v3_quaternion_apply(scratch_rot, 0, cent_lx, cent_ly, cent_lz, cqx, cqy, cqz, cqw);
         const cent_wx = scratch_rot[0] + c_pos_x;
         const cent_wy = scratch_rot[1] + c_pos_y;
         const cent_wz = scratch_rot[2] + c_pos_z;
@@ -315,13 +315,13 @@ function concave_recovery_penetration(
         // buried body is always inside SOME covering triangle's footprint,
         // so rejection never disables legitimate recovery — it only
         // silences far-away planes.
-        v3_quat3_apply(scratch_rot, 0, ax, ay, az, cqx, cqy, cqz, cqw);
+        v3_quaternion_apply(scratch_rot, 0, ax, ay, az, cqx, cqy, cqz, cqw);
         const wax = scratch_rot[0] + c_pos_x, way = scratch_rot[1] + c_pos_y, waz = scratch_rot[2] + c_pos_z;
-        v3_quat3_apply(scratch_rot, 0, bx, by, bz, cqx, cqy, cqz, cqw);
+        v3_quaternion_apply(scratch_rot, 0, bx, by, bz, cqx, cqy, cqz, cqw);
         const wbx = scratch_rot[0] + c_pos_x, wby = scratch_rot[1] + c_pos_y, wbz = scratch_rot[2] + c_pos_z;
-        v3_quat3_apply(scratch_rot, 0, cx_v, cy_v, cz_v, cqx, cqy, cqz, cqw);
+        v3_quaternion_apply(scratch_rot, 0, cx_v, cy_v, cz_v, cqx, cqy, cqz, cqw);
         const wcx = scratch_rot[0] + c_pos_x, wcy = scratch_rot[1] + c_pos_y, wcz = scratch_rot[2] + c_pos_z;
-        computeTriangleClosestPointToPointBarycentric(
+        tri3_closest_point_barycentric(
             scratch_bary, 0,
             convex_pos.x, convex_pos.y, convex_pos.z,
             wax, way, waz,