@woosh/meep-engine 3.37.0 → 3.39.0

package/src/engine/physics/cloth/ecs/cloth_write_back.js

@@ -1,7 +1,7 @@
-import { quat3_multiply } from "../../../../core/geom/3d/quaternion/quat3_multiply.js";
-import { v3_quaternion_apply } from "../../../../core/geom/vec3/v3_quaternion_apply.js";
+import { quat3_multiply_array } from "../../../../core/geom/3d/quaternion/quat3_multiply.js";
+import { v3_quaternion_apply_array } from "../../../../core/geom/vec3/v3_quaternion_apply.js";
 import {
-    v3_quaternion_apply_inverse
+    v3_quaternion_apply_inverse_array
 } from "../../../../core/geom/vec3/v3_quaternion_apply_inverse.js";
 import { t64_announce_change } from "../../../ecs/transform/t64_announce_change.js";
 import {
@@ -90,10 +90,9 @@ export function cloth_write_back(instance, ecd) {
     const ay = instance.anchor_translation[1];
     const az = instance.anchor_translation[2];
 
-    const aqx = instance.anchor_rotation[0];
-    const aqy = instance.anchor_rotation[1];
-    const aqz = instance.anchor_rotation[2];
-    const aqw = instance.anchor_rotation[3];
+    // The rotations go in as arrays, read where they sit: handed over as seven and eight numbers,
+    // each was boxed into a heap object wherever the call was not inlined.
+    const anchor_rotation = instance.anchor_rotation;
 
     const parent = instance.node_parent;
 
@@ -102,22 +101,13 @@ export function cloth_write_back(instance, ecd) {
 
         const n = node * 3;
 
-        v3_quaternion_apply(
-            transform, TRANSFORM64_TRANSLATION_OFFSET,
-            blended[n], blended[n + 1], blended[n + 2],
-            aqx, aqy, aqz, aqw
-        );
+        v3_quaternion_apply_array(transform, TRANSFORM64_TRANSLATION_OFFSET, blended, n, anchor_rotation, 0);
 
         transform[TRANSFORM64_TRANSLATION_OFFSET] += ax;
         transform[TRANSFORM64_TRANSLATION_OFFSET + 1] += ay;
         transform[TRANSFORM64_TRANSLATION_OFFSET + 2] += az;
 
-        quat3_multiply(
-            transform, TRANSFORM64_ROTATION_OFFSET,
-            aqx, aqy, aqz, aqw,
-            reconstructed[node * 4], reconstructed[node * 4 + 1],
-            reconstructed[node * 4 + 2], reconstructed[node * 4 + 3]
-        );
+        quat3_multiply_array(transform, TRANSFORM64_ROTATION_OFFSET, anchor_rotation, 0, reconstructed, node * 4);
 
         transform.updateMatrix();
 
@@ -164,24 +154,25 @@ export function cloth_write_local_pose(local, instance, node, parent) {
     const blended = instance.blended_position;
     const rotation = instance.blended_rotation;
 
-    const pqx = rotation[parent * 4];
-    const pqy = rotation[parent * 4 + 1];
-    const pqz = rotation[parent * 4 + 2];
-    const pqw = rotation[parent * 4 + 3];
-
-    v3_quaternion_apply_inverse(
-        local, TRANSFORM64_TRANSLATION_OFFSET,
-        blended[node * 3] - blended[parent * 3],
-        blended[node * 3 + 1] - blended[parent * 3 + 1],
-        blended[node * 3 + 2] - blended[parent * 3 + 2],
-        pqx, pqy, pqz, pqw
-    );
-
-    quat3_multiply(
-        local, TRANSFORM64_ROTATION_OFFSET,
-        -pqx, -pqy, -pqz, pqw,
-        rotation[node * 4], rotation[node * 4 + 1], rotation[node * 4 + 2], rotation[node * 4 + 3]
-    );
+    // Operands go in as arrays, the parent's rotation and the node's straight from the instance, the
+    // offset and the conjugate through scratch: handed over as seven and eight numbers, each was
+    // boxed into a heap object wherever the call was not inlined.
+    const offset = scratch_local_offset;
+
+    offset[0] = blended[node * 3] - blended[parent * 3];
+    offset[1] = blended[node * 3 + 1] - blended[parent * 3 + 1];
+    offset[2] = blended[node * 3 + 2] - blended[parent * 3 + 2];
+
+    v3_quaternion_apply_inverse_array(local, TRANSFORM64_TRANSLATION_OFFSET, offset, 0, rotation, parent * 4);
+
+    const conjugate = scratch_parent_conjugate;
+
+    conjugate[0] = -rotation[parent * 4];
+    conjugate[1] = -rotation[parent * 4 + 1];
+    conjugate[2] = -rotation[parent * 4 + 2];
+    conjugate[3] = rotation[parent * 4 + 3];
+
+    quat3_multiply_array(local, TRANSFORM64_ROTATION_OFFSET, conjugate, 0, rotation, node * 4);
 
     // `multiplyTransforms` reads the matrix, not the components, so a local
     // transform that is not refreshed here composes the pose it had last time.
@@ -218,3 +209,17 @@ function pose_pruned(instance, ecd) {
         t64_announce_change(ecd, instance.pruned_entity[i]);
     }
 }
+
+/**
+ * {@link cloth_write_local_pose}'s node position less its parent's, in the cloth's frame.
+ * @type {Float64Array}
+ * @private
+ */
+const scratch_local_offset = new Float64Array(3);
+
+/**
+ * {@link cloth_write_local_pose}'s parent rotation, conjugated: `[-x, -y, -z, w]`.
+ * @type {Float64Array}
+ * @private
+ */
+const scratch_parent_conjugate = new Float64Array(4);

package/src/engine/physics/cloth/playground/garment_build.js

@@ -157,9 +157,9 @@ export async function build_garment({ preset, dynamics, links, spacing, collide,
     cloth.fixedUpdate(1 / 60);
 
     const bind = skeleton.joint.map(entity => {
-        const t = ecd.getComponent(entity, Transform64).translation;
+        const t = ecd.getComponent(entity, Transform64);
 
-        return [t[0], t[1], t[2]];
+        return [t.translation_x, t.translation_y, t.translation_z];
     });
 
     return {
@@ -351,13 +351,13 @@ export function garment_sync_colliders(scene) {
         const t = scene.ecd.getComponent(part.node, Transform64);
 
         part.transform.setTranslation(
-            t.translation[0] + part.offset[0],
-            t.translation[1] + part.offset[1],
-            t.translation[2] + part.offset[2]
+            t.translation_x + part.offset[0],
+            t.translation_y + part.offset[1],
+            t.translation_z + part.offset[2]
         );
 
         part.transform.setRotation(
-            t.rotation[0], t.rotation[1], t.rotation[2], t.rotation[3]
+            t.rotation_x, t.rotation_y, t.rotation_z, t.rotation_w
         );
 
         part.transform.updateMatrix();

package/src/engine/physics/cloth/playground/garment_main.js

@@ -201,9 +201,9 @@ function draw() {
  * @returns {number} depth
  */
 function project_node(node, out, width, height) {
-    const t = scene.ecd.getComponent(node, Transform64).translation;
+    const t = scene.ecd.getComponent(node, Transform64);
 
-    return project(out, camera, t[0], t[1], t[2], width, height);
+    return project(out, camera, t.translation_x, t.translation_y, t.translation_z, width, height);
 }
 
 /**
@@ -291,11 +291,15 @@ function draw_bind(width, height) {
         const parent = parent_of(node);
         const parent_index = joint.indexOf(parent);
 
-        const from = parent_index >= 0
-            ? bind[parent_index]
-            : Array.from(scene.ecd.getComponent(parent, Transform64).translation);
+        if (parent_index >= 0) {
+            const from = bind[parent_index];
 
-        project(SCREEN, camera, from[0], from[1], from[2], width, height);
+            project(SCREEN, camera, from[0], from[1], from[2], width, height);
+        } else {
+            const from = scene.ecd.getComponent(parent, Transform64);
+
+            project(SCREEN, camera, from.translation_x, from.translation_y, from.translation_z, width, height);
+        }
         project(OTHER, camera, bind[i][0], bind[i][1], bind[i][2], width, height);
 
         context.beginPath();
@@ -356,13 +360,13 @@ function draw_frames(width, height) {
     for (const node of scene.joint) {
         const t = scene.ecd.getComponent(node, Transform64);
 
-        project(SCREEN, camera, t.translation[0], t.translation[1], t.translation[2], width, height);
+        project(SCREEN, camera, t.translation_x, t.translation_y, t.translation_z, width, height);
 
         for (const [colour, x, y, z] of axes) {
-            const qx = t.rotation[0];
-            const qy = t.rotation[1];
-            const qz = t.rotation[2];
-            const qw = t.rotation[3];
+            const qx = t.rotation_x;
+            const qy = t.rotation_y;
+            const qz = t.rotation_z;
+            const qw = t.rotation_w;
 
             const tx = 2 * (qy * z - qz * y);
             const ty = 2 * (qz * x - qx * z);
@@ -374,9 +378,9 @@ function draw_frames(width, height) {
 
             project(
                 OTHER, camera,
-                t.translation[0] + dx * length,
-                t.translation[1] + dy * length,
-                t.translation[2] + dz * length,
+                t.translation_x + dx * length,
+                t.translation_y + dy * length,
+                t.translation_z + dz * length,
                 width, height
             );
 

package/src/engine/physics/cloth/solver/cloth_contact_find.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cloth_contact_find.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/solver/cloth_contact_find.js"],"names":[],"mappings":"AAgHA;;;;;;;;;;;;;;;;;;GAkBG;AACH,6DARW,YAAY,GAAC,YAAY,QACzB,UAAU,SACV,MAAM,MACN,MAAM,GAGJ,MAAM,CAqLlB;AA/RD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2EG;AAEH;;;;;;;;;GASG;AACH,mCAFU,MAAM,CAEsB"}
+{"version":3,"file":"cloth_contact_find.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/solver/cloth_contact_find.js"],"names":[],"mappings":"AAgHA;;;;;;;;;;;;;;;;;;GAkBG;AACH,6DARW,YAAY,GAAC,YAAY,QACzB,UAAU,SACV,MAAM,MACN,MAAM,GAGJ,MAAM,CAwLlB;AAlSD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2EG;AAEH;;;;;;;;;GASG;AACH,mCAFU,MAAM,CAEsB"}

package/src/engine/physics/cloth/solver/cloth_contact_find.js

@@ -16,8 +16,8 @@ import {
 } from "../collider/ClothColliderRecord.js";
 import {
     cloth_collider_pose_at,
-    cloth_collider_signed_distance,
-    cloth_collider_to_local
+    cloth_collider_signed_distance_array,
+    cloth_collider_to_local_array
 } from "../collider/cloth_collider_sdf.js";
 import { CLOTH_CONTACT_SLOTS } from "./constraint/cloth_contact_row.js";
 
@@ -235,7 +235,10 @@ export function cloth_contact_find(state, table, keys, count, dt) {
                 continue;
             }
 
-            const distance = cloth_collider_signed_distance(NORMAL, 0, table, record, x, y, z);
+            // the particle where it sits, the distance beside the normal: no number crosses the call
+            cloth_collider_signed_distance_array(NORMAL, 0, table, record, position, p);
+
+            const distance = NORMAL[3];
 
             if (distance > reach) {
                 continue;
@@ -300,7 +303,7 @@ export function cloth_contact_find(state, table, keys, count, dt) {
                 friction_penalty[slot] = 0;
 
                 // A new contact sticks where the particle is now.
-                cloth_collider_to_local(anchor, slot * 3, table, record, x, y, z);
+                cloth_collider_to_local_array(anchor, slot * 3, table, record, position, p);
             }
 
             created++;
@@ -322,7 +325,7 @@ let TRAVEL = new Float64Array(0);
  * @type {Float64Array}
  * @private
  */
-const NORMAL = new Float64Array(3);
+const NORMAL = new Float64Array(4);
 
 /**
  * @type {Float64Array}

package/src/engine/physics/cloth/solver/cloth_solve_vertex.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cloth_solve_vertex.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/solver/cloth_solve_vertex.js"],"names":[],"mappings":"AAgFA;;;;;;;;;;;;;GAaG;AACH,gEANW,MAAM,qBACN,MAAM,mBACN,YAAY,GAAC,YAAY,GAAC,IAAI,QA6HxC"}
+{"version":3,"file":"cloth_solve_vertex.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/solver/cloth_solve_vertex.js"],"names":[],"mappings":"AAgFA;;;;;;;;;;;;;GAaG;AACH,gEANW,MAAM,qBACN,MAAM,mBACN,YAAY,GAAC,YAAY,GAAC,IAAI,QAgIxC"}

package/src/engine/physics/cloth/solver/cloth_solve_vertex.js

@@ -163,11 +163,14 @@ export function cloth_solve_vertex(state, particle, inverse_h_squared, collider_
 
     // The pivots of an SPD matrix are its `H` restricted to nested subspaces,
     // so all three positive *is* positive definiteness — the same claim §5.3
-    // makes, checked where it is actually used.
-    assert.ok(
-        pivot_x > 0 && pivot_y > 0 && pivot_z > 0,
-        `cloth vertex ${particle}: H is not positive definite (pivots ${pivot_x}, ${pivot_y}, ${pivot_z}) — the SPD-by-construction argument of §5.3 has been broken`
-    );
+    // makes, checked where it is actually used. The message is built only when the check fails: as
+    // an argument it was a string of four numbers per vertex per iteration.
+    if (!(pivot_x > 0 && pivot_y > 0 && pivot_z > 0)) {
+        assert.ok(
+            false,
+            `cloth vertex ${particle}: H is not positive definite (pivots ${pivot_x}, ${pivot_y}, ${pivot_z}) — the SPD-by-construction argument of §5.3 has been broken`
+        );
+    }
 
     const force_x = accumulator[CVA_F_X];
     const force_y = accumulator[CVA_F_Y];

package/src/engine/physics/cloth/solver/constraint/cloth_contact_row.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cloth_contact_row.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/physics/cloth/solver/constraint/cloth_contact_row.js"],"names":[],"mappings":"AAuHA;;;;;;;;GAQG;AACH,sDANW,YAAY,+BAEZ,MAAM,SACN,YAAY,GAAC,YAAY,QA8LnC;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,mEANW,MAAM,SACN,MAAM,eACN,MAAM,eACN,MAAM,qBACN,MAAM,QA8ChB;AAED;;;;;;;;;;;;;;;GAeG;AACH,oEALW,YAAY,GAAC,YAAY,QACzB,MAAM,eACN,MAAM,qBACN,MAAM,QAsGhB;AAxdD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2DG;AAEH;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,kCAFU,MAAM,CAEqB;AAErC;;;;;GAKG;AACH,qCAFU,MAAM,CAE2B"}
+{"version":3,"file":"cloth_contact_row.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/physics/cloth/solver/constraint/cloth_contact_row.js"],"names":[],"mappings":"AAuHA;;;;;;;;GAQG;AACH,sDANW,YAAY,+BAEZ,MAAM,SACN,YAAY,GAAC,YAAY,QA+LnC;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,mEANW,MAAM,SACN,MAAM,eACN,MAAM,eACN,MAAM,qBACN,MAAM,QA8ChB;AAED;;;;;;;;;;;;;;;GAeG;AACH,oEALW,YAAY,GAAC,YAAY,QACzB,MAAM,eACN,MAAM,qBACN,MAAM,QAqGhB;AAxdD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2DG;AAEH;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,kCAFU,MAAM,CAEqB;AAErC;;;;;GAKG;AACH,qCAFU,MAAM,CAE2B"}

package/src/engine/physics/cloth/solver/constraint/cloth_contact_row.js

@@ -5,9 +5,9 @@ import {
     CCR_STRIDE
 } from "../../collider/ClothColliderRecord.js";
 import {
-    cloth_collider_from_local,
-    cloth_collider_signed_distance,
-    cloth_collider_to_local
+    cloth_collider_from_local_array,
+    cloth_collider_signed_distance_array,
+    cloth_collider_to_local_array
 } from "../../collider/cloth_collider_sdf.js";
 import {
     CVA_F_X,
@@ -177,7 +177,11 @@ export function cloth_contact_accumulate(accumulator, state, particle, table) {
 
         const r = record * CCR_STRIDE;
 
-        const distance = cloth_collider_signed_distance(NORMAL, 0, table, record, x, y, z);
+        // The particle goes in where it sits and the distance comes back beside the normal:
+        // handed over and back as numbers, each was boxed wherever the call was not inlined.
+        cloth_collider_signed_distance_array(NORMAL, 0, table, record, position, self);
+
+        const distance = NORMAL[3];
 
         const offset = radius + table[r + CCR_INFLATION];
 
@@ -190,7 +194,7 @@ export function cloth_contact_accumulate(accumulator, state, particle, table) {
             // clamped out — and while it is, the friction anchor follows the
             // particle, so that when it *does* touch it sticks where it landed
             // rather than being dragged back to wherever it last was.
-            cloth_collider_to_local(anchor, slot * 3, table, record, x, y, z);
+            cloth_collider_to_local_array(anchor, slot * 3, table, record, position, self);
 
             friction_lambda[slot] = 0;
 
@@ -238,10 +242,7 @@ export function cloth_contact_accumulate(accumulator, state, particle, table) {
             continue;
         }
 
-        cloth_collider_from_local(
-            ANCHOR_WORLD, 0, table, record,
-            anchor[slot * 3], anchor[slot * 3 + 1], anchor[slot * 3 + 2]
-        );
+        cloth_collider_from_local_array(ANCHOR_WORLD, 0, table, record, anchor, slot * 3);
 
         const dx = x - ANCHOR_WORLD[0];
         const dy = y - ANCHOR_WORLD[1];
@@ -440,7 +441,9 @@ export function cloth_contact_dual_update(state, table, beta, k_max_ratio, inver
 
             const r = record * CCR_STRIDE;
 
-            const distance = cloth_collider_signed_distance(NORMAL, 0, table, record, x, y, z);
+            cloth_collider_signed_distance_array(NORMAL, 0, table, record, position, self);
+
+            const distance = NORMAL[3];
 
             const c = radius + table[r + CCR_INFLATION] - distance;
 
@@ -464,10 +467,7 @@ export function cloth_contact_dual_update(state, table, beta, k_max_ratio, inver
                 continue;
             }
 
-            cloth_collider_from_local(
-                ANCHOR_WORLD, 0, table, record,
-                anchor[slot * 3], anchor[slot * 3 + 1], anchor[slot * 3 + 2]
-            );
+            cloth_collider_from_local_array(ANCHOR_WORLD, 0, table, record, anchor, slot * 3);
 
             const dx = x - ANCHOR_WORLD[0];
             const dy = y - ANCHOR_WORLD[1];
@@ -515,7 +515,7 @@ function clamp_band(value, lo, hi) {
  * @type {Float64Array}
  * @private
  */
-const NORMAL = new Float64Array(3);
+const NORMAL = new Float64Array(4);
 
 /**
  * @type {Float64Array}

package/src/engine/physics/cloth/solver/find_non_finite_cloth_state.d.ts

@@ -17,6 +17,11 @@
  * carries state across steps: a multiplier that goes non-finite poisons every
  * subsequent step even after the positions that produced it have been reset.
  *
+ * Every test is `v - v === 0`, which is `Number.isFinite(v)` for a number — `v - v` is zero for any
+ * finite `v` and NaN for NaN and both infinities — without the call. Until V8 optimises this sweep,
+ * which takes a few hundred steps, `Number.isFinite` is a call into a builtin and every number handed
+ * to it is boxed into a heap object first.
+ *
  * @param {ClothState} state
  * @returns {string} "" when clean, else a description of the first non-finite value
  *

package/src/engine/physics/cloth/solver/find_non_finite_cloth_state.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"find_non_finite_cloth_state.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/solver/find_non_finite_cloth_state.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,gEALa,MAAM,CAmFlB"}
+{"version":3,"file":"find_non_finite_cloth_state.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/solver/find_non_finite_cloth_state.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,gEALa,MAAM,CAqGlB"}

package/src/engine/physics/cloth/solver/find_non_finite_cloth_state.js

@@ -17,6 +17,11 @@
  * carries state across steps: a multiplier that goes non-finite poisons every
  * subsequent step even after the positions that produced it have been reset.
  *
+ * Every test is `v - v === 0`, which is `Number.isFinite(v)` for a number — `v - v` is zero for any
+ * finite `v` and NaN for NaN and both infinities — without the call. Until V8 optimises this sweep,
+ * which takes a few hundred steps, `Number.isFinite` is a call into a builtin and every number handed
+ * to it is boxed into a heap object first.
+ *
  * @param {ClothState} state
  * @returns {string} "" when clean, else a description of the first non-finite value
  *
@@ -32,11 +37,15 @@ export function find_non_finite_cloth_state(state) {
     for (let i = 0; i < particle_count; i++) {
         const p = i * 3;
 
-        if (!Number.isFinite(position[p] + position[p + 1] + position[p + 2])) {
+        const position_sum = position[p] + position[p + 1] + position[p + 2];
+
+        if (!(position_sum - position_sum === 0)) {
             return `particle[${i}].position = (${position[p]}, ${position[p + 1]}, ${position[p + 2]})`;
         }
 
-        if (!Number.isFinite(velocity[p] + velocity[p + 1] + velocity[p + 2])) {
+        const velocity_sum = velocity[p] + velocity[p + 1] + velocity[p + 2];
+
+        if (!(velocity_sum - velocity_sum === 0)) {
             return `particle[${i}].velocity = (${velocity[p]}, ${velocity[p + 1]}, ${velocity[p + 2]})`;
         }
     }
@@ -47,11 +56,15 @@ export function find_non_finite_cloth_state(state) {
     const stretch_penalty = state.stretch_penalty;
 
     for (let row = 0; row < stretch_count; row++) {
-        if (!Number.isFinite(stretch_lambda[row])) {
+        const stretch_lambda_value = stretch_lambda[row];
+
+        if (!(stretch_lambda_value - stretch_lambda_value === 0)) {
             return `stretch[${row}].lambda = ${stretch_lambda[row]}`;
         }
 
-        if (!Number.isFinite(stretch_penalty[row])) {
+        const stretch_penalty_value = stretch_penalty[row];
+
+        if (!(stretch_penalty_value - stretch_penalty_value === 0)) {
             return `stretch[${row}].penalty = ${stretch_penalty[row]}`;
         }
     }
@@ -64,11 +77,15 @@ export function find_non_finite_cloth_state(state) {
     for (let row = 0; row < bend_count; row++) {
         const dual = row * 3;
 
-        if (!Number.isFinite(bend_lambda[dual] + bend_lambda[dual + 1] + bend_lambda[dual + 2])) {
+        const bend_lambda_sum = bend_lambda[dual] + bend_lambda[dual + 1] + bend_lambda[dual + 2];
+
+        if (!(bend_lambda_sum - bend_lambda_sum === 0)) {
             return `bend[${row}].lambda = (${bend_lambda[dual]}, ${bend_lambda[dual + 1]}, ${bend_lambda[dual + 2]})`;
         }
 
-        if (!Number.isFinite(bend_penalty[row])) {
+        const bend_penalty_value = bend_penalty[row];
+
+        if (!(bend_penalty_value - bend_penalty_value === 0)) {
             return `bend[${row}].penalty = ${bend_penalty[row]}`;
         }
     }
@@ -80,11 +97,15 @@ export function find_non_finite_cloth_state(state) {
     const leash_target = state.leash_target;
 
     for (let row = 0; row < leash_count; row++) {
-        if (!Number.isFinite(leash_lambda[row])) {
+        const leash_lambda_value = leash_lambda[row];
+
+        if (!(leash_lambda_value - leash_lambda_value === 0)) {
             return `leash[${row}].lambda = ${leash_lambda[row]}`;
         }
 
-        if (!Number.isFinite(leash_penalty[row])) {
+        const leash_penalty_value = leash_penalty[row];
+
+        if (!(leash_penalty_value - leash_penalty_value === 0)) {
             return `leash[${row}].penalty = ${leash_penalty[row]}`;
         }
 
@@ -95,7 +116,9 @@ export function find_non_finite_cloth_state(state) {
         // than a solve.
         const target = row * 3;
 
-        if (!Number.isFinite(leash_target[target] + leash_target[target + 1] + leash_target[target + 2])) {
+        const leash_target_sum = leash_target[target] + leash_target[target + 1] + leash_target[target + 2];
+
+        if (!(leash_target_sum - leash_target_sum === 0)) {
             return `leash[${row}].target = (${leash_target[target]}, ${leash_target[target + 1]}, ${leash_target[target + 2]})`;
         }
     }

package/src/engine/physics/constraint/solve_constraints.d.ts

@@ -24,21 +24,63 @@
  */
 export function swing_twist_error(dx: number, dy: number, dz: number, dw: number, out: Float64Array): void;
 /**
- * Solve every joint for one substep: recompute geometry at the current poses,
- * derive each DOF's row parameters from its mode, replay the per-substep
- * warm-start, and run `iters` velocity iterations.
+ * {@link swing_twist_error} with `qD` read from `q[q_offset ..+3]`, `[x, y, z, w]`: the one place the
+ * arithmetic lives. For a caller whose inlining budget is spent, where a call taking the four numbers
+ * would box each into a new heap object.
+ *
+ * @param {Float64Array} q
+ * @param {number} q_offset
+ * @param {Float64Array} out  length-3 destination (frame-axis positions)
+ */
+export function swing_twist_error_array(q: Float64Array, q_offset: number, out: Float64Array): void;
+/**
+ * Solve every joint for one substep: prepare each joint's rows at the current
+ * poses, then run `iters` Gauss-Seidel passes over all of them. The first pass
+ * prepares, warm-starts and solves each joint in turn; passes 2..iters
+ * re-solve every live joint from its prepared rows, in the same order. The
+ * prepared rows stay for this substep's {@link relax_joints}.
+ *
+ * The warm start stays inside the first pass, interleaved with the solve, on
+ * purpose: replaying every joint's impulse before solving any (Box3D's order)
+ * is unstable on these hard Baumgarte rows — measured, a hanging 10-link
+ * chain at one pass opens by ~99 m, and a hanging 20-link chain at eight
+ * passes diverges from rest. Box3D gets away with it on soft rows.
  *
  * Called once per substep from `PhysicsSystem.fixedUpdate`, after the contact
  * solve so the two share the substep / warm-start cadence.
  *
- * @param {Joint[]} joints  live joints (sparse array; holes skipped)
+ * @param {Joint[]} joints  live joints in solve order (holes skipped)
  * @param {PhysicsSystem} system  reads `__bodies` / `__transforms` / index map
  * @param {number} dt_sub  substep size in seconds (the SPOOK gain is derived
  *   from it, matching the contact solver's per-substep position stiffness)
- * @param {number} iters  velocity iterations
- * @param {boolean} [reverse]  A2: traverse the joint array tip→root this call
- *   (the caller alternates it per substep for a symmetric Gauss-Seidel sweep, so
- *   chain impulses propagate both ways). Default false ⇒ original root→tip order.
+ * @param {number} iters  passes over the joint set. 0 turns the joints off for
+ *   the substep: nothing is prepared, warm-started or solved, and so nothing
+ *   is relaxed either — the solver leaves the jointed bodies' velocities alone.
+ * @param {boolean} [reverse]  A2: sweep the joint array tip→root this substep
+ *   (the caller alternates it per substep for a symmetric Gauss-Seidel sweep,
+ *   so chain impulses propagate both ways). Default false ⇒ root→tip.
  */
 export function solve_joints(joints: Joint[], system: PhysicsSystem, dt_sub: number, iters: number, reverse?: boolean): void;
+/**
+ * The relax pass: one more sweep over the joints the last
+ * {@link solve_joints} prepared, re-solving their LIMITED, MOTOR and SPRING
+ * rows against the relax bias — the velocity target without the position
+ * correction (see the module doc) — from the prepared rows. Called once per
+ * substep from `PhysicsSystem.fixedUpdate`, after the position integrate,
+ * with the joints and sweep direction of that substep's solve.
+ *
+ * LOCKED rows sit it out, where Box3D relaxes every row. Its rows are soft;
+ * on these hard Baumgarte rows relaxing the LOCKED ones as well widened the
+ * ragdoll drop's settle tail. Per-twin settled limb speed, median / 94th
+ * percentile over 401 twins: 0.31 / 1.65 m/s with this relax, 0.27 / 3.55
+ * with none, 0.49 / 5.6 relaxing every row. Re-deriving the lever arms at the
+ * integrated pose while keeping the prepared K⁻¹ and frame made the full relax
+ * worse still, 4.2 / 7.9 (101 twins). LOCKED rows need no relax: the next
+ * substep's biased solve sets their velocity outright.
+ *
+ * @param {Joint[]} joints  the array the last solve_joints was given
+ * @param {PhysicsSystem} system  reads `__solver_state`
+ * @param {boolean} [reverse]  the sweep direction of that solve
+ */
+export function relax_joints(joints: Joint[], system: PhysicsSystem, reverse?: boolean): void;
 //# sourceMappingURL=solve_constraints.d.ts.map

package/src/engine/physics/constraint/solve_constraints.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"solve_constraints.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/constraint/solve_constraints.js"],"names":[],"mappings":"AA+SA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,sCANW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,OACN,YAAY,QAkCtB;AAuKD;;;;;;;;;;;;;;;;GAgBG;AACH,qCATW,OAAO,iCAEP,MAAM,SAEN,MAAM,YACN,OAAO,QAuSjB"}
+{"version":3,"file":"solve_constraints.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/constraint/solve_constraints.js"],"names":[],"mappings":"AAwZA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,sCANW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,OACN,YAAY,QAWtB;AAKD;;;;;;;;GAQG;AACH,2CAJW,YAAY,YACZ,MAAM,OACN,YAAY,QAoCtB;AA+gBD;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,qCAXW,OAAO,iCAEP,MAAM,SAEN,MAAM,YAGN,OAAO,QAgCjB;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,qCAJW,OAAO,mCAEP,OAAO,QAgBjB"}