@woosh/meep-engine 3.63.3 → 3.64.1

package/src/engine/physics/vehicle/RaycastVehicle.js

@@ -1,33 +1,92 @@
 import { Ray3 } from "../../../core/geom/3d/ray/Ray3.js";
-import { PhysicsSurfacePoint } from "../queries/PhysicsSurfacePoint.js";
+import { v3_length } from "../../../core/geom/vec3/v3_length.js";
 import { v3_quaternion_apply } from "../../../core/geom/vec3/v3_quaternion_apply.js";
 import { v3_set } from "../../../core/geom/vec3/v3_set.js";
-import { v3_length } from "../../../core/geom/vec3/v3_length.js";
-import { angular_effective_mass_raw } from "../inertia/world_inverse_inertia.js";
-import { BodyKind } from "../ecs/BodyKind.js";
+import { lu_factor_linear_system } from "../../../core/math/linalg/lu_factor_linear_system.js";
+import { lu_solve_linear_system } from "../../../core/math/linalg/lu_solve_linear_system.js";
+import { solve_box_constrained_qp } from "../../../core/math/linalg/solve_box_constrained_qp.js";
+import { soft_spring_coefficients } from "../constraint/soft_spring_coefficients.js";
+import { BodyKind } from "../ecs/BodyKind.js";
 import { locked_inverse_inertia } from "../inertia/locked_inverse_inertia.js";
+import { world_inverse_inertia_apply_raw } from "../inertia/world_inverse_inertia.js";
+import { PhysicsSurfacePoint } from "../queries/PhysicsSurfacePoint.js";
 
 /**
  * # Raycast vehicle controller
  *
  * The vehicle model most games ship: a single rigid-body **chassis** plus a set
  * of **raycast wheels**. Each wheel is not a body — it is a downward ray from a
- * chassis-local mount point. Every frame, for each wheel, the controller:
+ * chassis-local mount point. Every step, the controller:
  *
- *   1. casts the suspension ray and, on a ground hit, measures the spring
- *      compression;
- *   2. applies a spring + damper **suspension force** along the contact normal
- *      (this is what holds the chassis up);
- *   3. applies **tyre friction** at the contact patch — a lateral grip impulse
+ *   1. casts each wheel's suspension ray and, on a ground hit, measures the
+ *      spring compression;
+ *   2. applies **tyre friction** at each contact patch — a lateral grip impulse
  *      that resists sideways slide, plus a longitudinal drive / brake impulse,
- *      the two clamped together to a friction circle `μ·N`.
+ *      the two clamped together to a friction circle `μ·N`, `N` the push the
+ *      wheel's spring gives over the step — against the patch's motion across
+ *      the whole step (below);
+ *   3. pushes the chassis away from the ground at the grounded wheels' contacts
+ *      with their spring + damper **suspension**, all of them solved together
+ *      (below) — this is what holds the chassis up.
+ *
+ * ## The suspension is one implicit step of every grounded spring
+ *
+ * Each grounded wheel's spring is a soft constraint along its contact normal
+ * ({@link soft_spring_coefficients}), and the controller solves all of them at
+ * once as a single backward-Euler step: it finds the impulses after which every
+ * spring pushes with `k·x + c·ẋ`, `x` the compression the coming step ends at and
+ * `ẋ` its rate across the step, given where the step carries the chassis — under
+ * gravity, its damping and the forces accumulated on it
+ * ({@link PhysicsSystem#predictStepMeanVelocity}), the tyres' impulses, applied
+ * first, and the springs' own, every one of which moves the chassis at every
+ * wheel. That is stable for any stiffness, damping, chassis mass and inertia,
+ * wheel layout and step; a car left alone settles with each spring at its static
+ * deflection. A spring pushes, and no harder than `suspensionMaxForce`: the solve
+ * is a small bound-constrained problem ({@link solve_box_constrained_qp}).
+ *
+ * `M⁻¹` below is how an impulse applied before the step moves the chassis' mean
+ * motion across it: its inverse mass and inertia, times what of a velocity change
+ * the step keeps in its mean as the chassis' damping decays it
+ * ({@link PhysicsSystem#predictStepMeanVelocityShare}).
+ *
+ * A tyre's friction circle needs the push its spring gives over the step, which
+ * waits on the tyres. The springs are solved once beforehand for it, against the
+ * chassis' motion with every tyre pushing as it did the step before: exact while
+ * the car holds a line, a step behind when it changes one. It only bounds the
+ * tyres' impulses, so it costs the solve nothing in stability.
+ *
+ * ## A tyre grips against the step's motion
+ *
+ * A gripping tyre holds its patch still across the step, not only as the step
+ * starts. Two things move the patch after the tyres act: gravity, through the
+ * step ({@link PhysicsSystem#predictStepMeanVelocity}), and the springs. The
+ * patch sits below the chassis' centre of mass, so a tyre impulse tips the
+ * chassis as well as sliding it, and the springs push the tip back. So each tyre
+ * cancels its patch's slip, along and across at once, in the chassis' mean
+ * motion over the step, with the springs in it: pushing as the solve beforehand
+ * found, and every spring that pushes freely in that solve answering each tyre
+ * impulse as the spring solve will. The tyres see the chassis through
+ * `W = M⁻¹ − M⁻¹·J_sᵀ·(J_s·M⁻¹·J_sᵀ + Γ)⁻¹·J_s·M⁻¹`, `J_s` those springs' rows
+ * and `Γ` their compliances. That holds while the same springs push freely: in
+ * the step one starts or stops, the tyres miss by its change. Like the springs,
+ * the tyres take each contact, its lever and its directions as the step starts.
+ * A braked car on a slope it can hold stays put at any step.
  *
- * Steering rotates the steered wheels' forward direction; a drive force is split
- * across the driven wheels. It is a *controller on top of the public physics
- * API* (`raycast` + `applyForceAt` + `applyImpulseAt`), not a new constraint —
- * call {@link update} once per frame **before** `PhysicsSystem.fixedUpdate`, so
- * the suspension force it accumulates is integrated by that step and the
- * friction impulses act on the current velocity.
+ * The tyres take turns, once each per step, each starting from the impulse it
+ * applied the step before, within this step's brake and friction circle. A car
+ * on a slope it can hold settles with every patch held, whatever order its
+ * wheels are listed in. How the wheels share the hold is not fixed: rigid
+ * patches grip in more directions than the chassis has ways to slide, and the
+ * share the turns settle on depends on that order.
+ *
+ * Steering turns the steered wheels so that their axles pass through one turn
+ * centre ({@link setSteering}): the tyres' grips then agree on the point the
+ * chassis turns about. A drive force is split across the driven wheels.
+ *
+ * It is a *controller on top of the public physics API* (`raycast`,
+ * `predictStepMeanVelocity`, `applyImpulseAt`), not a new constraint: call
+ * {@link update} once per fixed step with that step's `dt`, and the impulses it
+ * applies to the chassis are integrated by the next `PhysicsSystem.fixedUpdate`.
  *
  * The 6-DOF joint (spring linear + motor angular) is the alternative
  * "simulated wheel" path; this raycast controller is the lighter, more robust
@@ -38,33 +97,61 @@ import { locked_inverse_inertia } from "../inertia/locked_inverse_inertia.js";
  * @copyright Company Named Limited (c) 2026
  */
 
+/** Offset of the contact normal in a wheel's contact frame. */
+const FRAME_NORMAL = 0;
+/** Offset of the forward (rolling) direction in a wheel's contact frame. */
+const FRAME_FORWARD = 3;
+/** Offset of the side direction in a wheel's contact frame. */
+const FRAME_SIDE = 6;
+
 const scratch_v = new Float64Array(3);
-const scratch_i = new Float64Array(3);
-const scratch_ii = new Float64Array(3);
+
+/** What the chassis' mean motion across the step keeps of a velocity change, linear at 0 and angular at 1. */
+const scratch_share = new Float64Array(2);
+
+/** A wheel's stiffness, damping and the step, for {@link soft_spring_coefficients}. */
+const scratch_spring_params = new Float64Array(3);
+/** A wheel's spring compliance `γ` at 0 and bias rate `β` at 1, from {@link soft_spring_coefficients}. */
+const scratch_spring = new Float64Array(2);
 
 /**
- * Effective mass denominator for a unit-direction velocity constraint at a
- * body-relative point: `invM + (r×d)·Iw⁻¹·(r×d)`. The angular term is the
- * shared {@link angular_effective_mass_raw} kernel — the same math the
- * contact/joint solver runs, so the two paths stay bit-identical.
- * @returns {number}
+ * A tyre's drive, brake and side impulse for {@link RaycastVehicle#__grip}. The numbers travel in an
+ * array because a number handed to a call V8 does not inline is boxed into a new heap object.
  */
-function effective_mass(rb, transform, invM, rx, ry, rz, dx, dy, dz) {
-    let k = invM;
-    locked_inverse_inertia(scratch_ii, 0, rb);
-    const iix = scratch_ii[0];
-    const iiy = scratch_ii[1];
-    const iiz = scratch_ii[2];
-    if (iix !== 0 || iiy !== 0 || iiz !== 0) {
-        k += angular_effective_mass_raw(
-            iix, iiy, iiz,
-            transform.rotation_x, transform.rotation_y, transform.rotation_z, transform.rotation_w,
-            rx, ry, rz,
-            dx, dy, dz,
-            scratch_i
-        );
+const scratch_grip = new Float64Array(3);
+
+/** A wheel's directions in the plane it steers in, from {@link wheel_plan_frame}. */
+const scratch_plan = new Float64Array(6);
+
+/**
+ * Wheel `w`'s directions in the plane it steers in, square to its suspension axis, local: its forward
+ * direction there at `out[0..2]`, then `up × forward` at `out[3..5]`, the way a positive
+ * {@link Wheel#steering} turns it. Both are unit, or zero for a wheel whose forward direction is its
+ * suspension axis.
+ * @param {Float64Array} out
+ * @param {Wheel} w
+ */
+function wheel_plan_frame(out, w) {
+    const d = w.localSuspensionDir;
+    const f = w.localForward;
+
+    const along = f[0] * d[0] + f[1] * d[1] + f[2] * d[2];
+    let fx = f[0] - along * d[0], fy = f[1] - along * d[1], fz = f[2] - along * d[2];
+
+    const length = v3_length(fx, fy, fz);
+
+    if (length > 0) {
+        fx /= length; fy /= length; fz /= length;
     }
-    return k;
+
+    out[0] = fx;
+    out[1] = fy;
+    out[2] = fz;
+
+    // up × forward with up = −d: forward × d.
+    out[3] = fy * d[2] - fz * d[1];
+    out[4] = fz * d[0] - fx * d[2];
+    out[5] = fx * d[1] - fy * d[0];
 }
 
 /** Rotate vector `(vx,vy,vz)` about unit axis `(ux,uy,uz)` by `angle`, into `out`. */
@@ -119,16 +206,25 @@ export class Wheel {
     /** Body id of the surface under the wheel, or −1. */
     contactBodyId = -1;
 
-    /** Current steering angle (rad), set via {@link RaycastVehicle#setSteering}. */
+    /**
+     * This wheel's steering angle (rad): its forward direction turned about its suspension axis, toward
+     * `up × forward` when positive. {@link RaycastVehicle#setSteering} sets every steered wheel's.
+     */
     steering = 0;
 
     /** Accumulated spin angle (rad) for rendering. */
     rotation = 0;
 
-    /** Forward ground speed at the contact (m/s). */
+    /**
+     * Forward ground speed at the contact across the coming step (m/s): the chassis' mean velocity there
+     * over the step, along the wheel's forward direction, with every impulse of the update in it.
+     */
     forwardSpeed = 0;
 
-    /** Suspension force magnitude applied this frame (N). */
+    /**
+     * The suspension's push in the last {@link RaycastVehicle#update}, as a force: the impulse it
+     * applied along the contact normal, divided by the step (N).
+     */
     suspensionForce = 0;
 
     constructor() {
@@ -147,15 +243,135 @@ export class RaycastVehicle {
     __ray = new Ray3();
     __hit = new PhysicsSurfacePoint();
 
-    // Reused force / impulse / point payloads for the public API calls.
-    __force = new Float64Array(3);
+    /** Reused impulse payload for applyImpulseAt. @type {Float64Array} */
+    __impulse = new Float64Array(3);
+
+    /**
+     * The chassis' mean linear and angular velocity across the coming step: before the springs push, for
+     * the spring solves; with them pushing, while the tyres solve and for each wheel's ground speed.
+     * @type {Float64Array}
+     */
+    __mean_linear = new Float64Array(3);
+    /** @type {Float64Array} */
+    __mean_angular = new Float64Array(3);
+
+    /** The chassis' mean velocity across the step per unit impulse applied before it, `M⁻¹`'s linear part. */
+    __mean_inverse_mass = 0;
+
+    /**
+     * `M⁻¹`'s angular part, as the chassis' body-local inverse inertia diagonal (LockRot*-masked) times the
+     * angular share: turned to the world by the pose, its mean spin across the step per unit angular impulse.
+     * @type {Float64Array}
+     */
+    __mean_inverse_inertia = new Float64Array(3);
+
+    // ── Per wheel ─────────────────────────────────────────────────────────────
+
+    /** Contact normal, forward and side directions (at FRAME_*), 9 per wheel. @type {Float64Array} */
+    __wheel_frame = new Float64Array(0);
+
+    /** The contact's offset from the chassis' centre, 3 per wheel. @type {Float64Array} */
+    __wheel_lever = new Float64Array(0);
+
+    /** 1 where the forward direction lies in the contact plane, so the tyre can grip and roll. @type {Uint8Array} */
+    __wheel_rolls = new Uint8Array(0);
+
+    /**
+     * The tyre impulse the wheel applied in the last update, along its forward and side directions, 2 per
+     * wheel; zero for a wheel that applied none.
+     * @type {Float64Array}
+     */
+    __wheel_tyre = new Float64Array(0);
+
+    /** The most impulse the tyre may apply this step, `μ·N·dt`. @type {Float64Array} */
+    __wheel_budget = new Float64Array(0);
+
+    /**
+     * The brake's part of the forward impulse in {@link __wheel_tyre}: what the tyre applied along its
+     * forward direction, less the drive. The tyre starts the next update from it.
+     * @type {Float64Array}
+     */
+    __wheel_brake = new Float64Array(0);
+
+    /**
+     * The chassis' mean velocity across the step per unit tyre impulse, the free springs answering it:
+     * `W·Jᵀ` for the forward, then the side direction, each linear then angular, 12 per wheel.
+     * @type {Float64Array}
+     */
+    __wheel_response = new Float64Array(0);
+
+    /**
+     * The wheel's block of `J·W·Jᵀ`, how a unit tyre impulse changes its patch's slip: forward on forward,
+     * side on side, and either on the other, 3 per wheel.
+     * @type {Float64Array}
+     */
+    __wheel_block = new Float64Array(0);
+
+    // ── The springs that push freely in the solve before the tyres, answering them ──
+
+    /** How many there are. */
+    __free_count = 0;
+
+    /** Their rows. @type {Uint32Array} */
+    __free_row = new Uint32Array(0);
+
+    /**
+     * Their block of {@link __row_matrix}, `J_s·M⁻¹·J_sᵀ + Γ`, times {@link __free_scale}, LU-factored.
+     * @type {Float64Array}
+     */
+    __free_matrix = new Float64Array(0);
+
+    /** The LU factorisation's pivots. @type {Uint32Array} */
+    __free_pivot = new Uint32Array(0);
+
+    /** One over the block's largest diagonal. */
+    __free_scale = 1;
+
+    /** Each free spring's speed per unit of one tyre impulse, `J_s·M⁻¹·Jᵀ`. @type {Float64Array} */
+    __free_speed = new Float64Array(0);
 
     /**
-     * World contact point handed to applyForceAt / applyImpulseAt, which read a pose by index so a
-     * transform's own translation view can go straight in.
+     * How much less each free spring pushes per unit of one tyre impulse,
+     * `(J_s·M⁻¹·J_sᵀ + Γ)⁻¹·J_s·M⁻¹·Jᵀ`.
      * @type {Float64Array}
      */
-    __point = new Float64Array(3);
+    __free_answer = new Float64Array(0);
+
+    // ── Per spring row: a grounded wheel whose spring has stiffness or damping ──
+
+    /** The wheel. @type {Uint32Array} */
+    __row_wheel = new Uint32Array(0);
+
+    /** The contact normal `n`, then `r × n`, 6 per row. @type {Float64Array} */
+    __row_jacobian = new Float64Array(0);
+
+    /**
+     * `M⁻¹`'s angular part on `r × n`: the chassis' mean spin across the step per unit impulse along the row,
+     * 3 per row.
+     * @type {Float64Array}
+     */
+    __row_response = new Float64Array(0);
+
+    /** The spring's compliance `γ`. @type {Float64Array} */
+    __row_compliance = new Float64Array(0);
+
+    /** `β·x`, the velocity the spring restores at. @type {Float64Array} */
+    __row_restore = new Float64Array(0);
+
+    /** `β·x − J·v̄`: what the spring asks for against where the step carries the chassis. @type {Float64Array} */
+    __row_rhs = new Float64Array(0);
+
+    /** The least impulse: a spring does not pull. @type {Float64Array} */
+    __row_lower = new Float64Array(0);
+
+    /** The most impulse, `suspensionMaxForce·dt`. @type {Float64Array} */
+    __row_upper = new Float64Array(0);
+
+    /** The impulses solved for. @type {Float64Array} */
+    __row_impulse = new Float64Array(0);
+
+    /** Rows × rows, column-major: `J·M⁻¹·Jᵀ` plus each row's compliance on the diagonal. @type {Float64Array} */
+    __row_matrix = new Float64Array(0);
 
     /**
      * @param {PhysicsSystem} system
@@ -215,10 +431,115 @@ export class RaycastVehicle {
         return w;
     }
 
-    /** Set the steering angle (rad) on every steered wheel. */
+    /**
+     * Steer: turn every steered wheel so that its axle passes through one turn centre on a line across the
+     * chassis, and the tyres' grips agree on the point the chassis turns about. Each wheel's own angle goes
+     * into its {@link Wheel#steering}, from the wheels as they are configured when this is called. The
+     * wheels are taken to share their suspension axis and their straight-ahead direction, as a car's do;
+     * where they differ, their axles need not meet.
+     *
+     * The line passes through the unsteered wheels' mean mount position: the line their axles share.
+     * Where they sit on more than one line, no centre suits them all, and this one leaves them the least
+     * side slip, summed in squares. With every wheel steered, it passes through all the wheels' mean
+     * position: the line that needs the least steering, summed in squares, in a gentle turn.
+     *
+     * `angle` is the single-track ("bicycle") model's steering angle of the steered wheels farthest from
+     * the line, which turn the most: that of one wheel standing at the steered wheels' mean place across
+     * the chassis and as far ahead of the line as they are from it, with its axle through the centre.
+     * Steered wheels nearer the line turn less, and one on it changes nothing. Positive turns the chassis
+     * toward `up × forward` (+x for the default axes), where a positive {@link Wheel#steering} turns a
+     * wheel's forward direction; a steered wheel behind the line turns the other way. At 0 every wheel
+     * points straight. At ±π/2 the chassis pivots about the point of the line beside that one wheel, and
+     * the steered wheels on the inside of it turn past π/2. With every steered wheel on the line, to the
+     * rounding of the mean positions, none can move the centre along it, and each points straight.
+     *
+     * @param {number} angle radians
+     */
     setSteering(angle) {
-        for (let i = 0; i < this.wheels.length; i++) {
-            if (this.wheels[i].steered) this.wheels[i].steering = angle;
+        const wheels = this.wheels;
+        const wheel_count = wheels.length;
+
+        // The unsteered wheels' and the steered wheels' mean mount positions, and the largest coordinate,
+        // which bounds the rounding those means carry.
+        let unsteered = 0, ux = 0, uy = 0, uz = 0;
+        let steered = 0, sx = 0, sy = 0, sz = 0;
+        let extent = 0;
+
+        for (let i = 0; i < wheel_count; i++) {
+            const w = wheels[i];
+            const p = w.localPosition;
+
+            if (w.steered) {
+                sx += p[0]; sy += p[1]; sz += p[2];
+                steered++;
+            } else {
+                ux += p[0]; uy += p[1]; uz += p[2];
+                unsteered++;
+            }
+
+            extent = Math.max(extent, Math.abs(p[0]), Math.abs(p[1]), Math.abs(p[2]));
+        }
+
+        if (steered === 0) {
+            return;
+        }
+
+        sx /= steered; sy /= steered; sz /= steered;
+
+        // A point of the centre's line: the unsteered wheels' mean, or with none, every wheel's.
+        let cx = sx, cy = sy, cz = sz;
+
+        if (unsteered > 0) {
+            cx = ux / unsteered; cy = uy / unsteered; cz = uz / unsteered;
+        }
+
+        const plan = scratch_plan;
+
+        // How far ahead of the line the single-track wheel stands: as far as the steered wheels farthest
+        // from it.
+        let reach = 0;
+
+        for (let i = 0; i < wheel_count; i++) {
+            const w = wheels[i];
+
+            if (!w.steered) {
+                continue;
+            }
+
+            wheel_plan_frame(plan, w);
+
+            const p = w.localPosition;
+            const distance = Math.abs((p[0] - cx) * plan[0] + (p[1] - cy) * plan[1] + (p[2] - cz) * plan[2]);
+
+            if (distance > reach) {
+                reach = distance;
+            }
+        }
+
+        // A mean of n coordinates carries up to (n − 1)·ε/2 of the largest; taken along a unit direction and
+        // off a mount position, a distance under 2·n·ε of it is rounding, not a wheel off the line.
+        const rounding = 2 * wheel_count * Number.EPSILON * extent;
+
+        const sine = Math.sin(angle);
+        const cosine = Math.cos(angle);
+
+        for (let i = 0; i < wheel_count; i++) {
+            const w = wheels[i];
+
+            if (!w.steered) {
+                continue;
+            }
+
+            wheel_plan_frame(plan, w);
+
+            // The wheel's distance ahead of the line, and the single-track wheel's offset across from it.
+            const p = w.localPosition;
+            const ahead = (p[0] - cx) * plan[0] + (p[1] - cy) * plan[1] + (p[2] - cz) * plan[2];
+            const across = (sx - p[0]) * plan[3] + (sy - p[1]) * plan[4] + (sz - p[2]) * plan[5];
+
+            // The centre sits `reach·cot(angle)` across from the single-track wheel, on the line; the wheel
+            // turns square to the way to it, rolling as the single-track wheel does.
+            w.steering = reach > rounding ? Math.atan2(ahead * sine, across * sine + reach * cosine) : 0;
         }
     }
 
@@ -229,28 +550,105 @@ export class RaycastVehicle {
     setBrake(force) { this.__brakeForce = force; }
 
     /**
-     * Step the vehicle: cast suspension rays, apply suspension + tyre forces.
-     * Call once per frame **before** `PhysicsSystem.fixedUpdate(dt)` with the
-     * same `dt`.
+     * Size the per-wheel and per-row storage for `wheel_count` wheels, keeping each wheel's last tyre
+     * impulse and its brake's part.
+     * @param {number} wheel_count
+     * @private
+     */
+    __reserve(wheel_count) {
+        if (this.__wheel_rolls.length >= wheel_count) {
+            return;
+        }
+
+        const tyre = new Float64Array(wheel_count * 2);
+        tyre.set(this.__wheel_tyre);
+        this.__wheel_tyre = tyre;
+
+        const brake = new Float64Array(wheel_count);
+        brake.set(this.__wheel_brake);
+        this.__wheel_brake = brake;
+
+        this.__wheel_frame = new Float64Array(wheel_count * 9);
+        this.__wheel_lever = new Float64Array(wheel_count * 3);
+        this.__wheel_rolls = new Uint8Array(wheel_count);
+        this.__wheel_budget = new Float64Array(wheel_count);
+        this.__wheel_response = new Float64Array(wheel_count * 12);
+        this.__wheel_block = new Float64Array(wheel_count * 3);
+
+        this.__free_row = new Uint32Array(wheel_count);
+        this.__free_matrix = new Float64Array(wheel_count * wheel_count);
+        this.__free_pivot = new Uint32Array(wheel_count);
+        this.__free_speed = new Float64Array(wheel_count);
+        this.__free_answer = new Float64Array(wheel_count);
+
+        this.__row_wheel = new Uint32Array(wheel_count);
+        this.__row_jacobian = new Float64Array(wheel_count * 6);
+        this.__row_response = new Float64Array(wheel_count * 3);
+        this.__row_compliance = new Float64Array(wheel_count);
+        this.__row_restore = new Float64Array(wheel_count);
+        this.__row_rhs = new Float64Array(wheel_count);
+        this.__row_lower = new Float64Array(wheel_count);
+        this.__row_upper = new Float64Array(wheel_count);
+        this.__row_impulse = new Float64Array(wheel_count);
+        this.__row_matrix = new Float64Array(wheel_count * wheel_count);
+    }
+
+    /**
+     * Step the vehicle: cast the suspension rays, apply the tyre impulses, then push the chassis up on its
+     * grounded springs. Every impulse acts on the chassis velocity at once, for the next
+     * `PhysicsSystem.fixedUpdate` to integrate. Call once per fixed step, with that step's `dt`.
      * @param {number} dt
      */
     update(dt) {
         const rb = this.chassisBody;
         if (rb.kind !== BodyKind.Dynamic || dt <= 0) return;
         const tr = this.chassisTransform;
-        const invMass = rb.mass > 0 ? 1 / rb.mass : 0;
+        const wheels = this.wheels;
+        const wheel_count = wheels.length;
+
+        this.__reserve(wheel_count);
+
+        // M⁻¹: what of an impulse applied now the chassis' mean motion across the step carries.
+        this.system.predictStepMeanVelocityShare(scratch_share, rb, dt);
+
+        const mean_inverse_mass = rb.mass > 0 ? scratch_share[0] / rb.mass : 0;
+        const mean_inverse_inertia = this.__mean_inverse_inertia;
+
+        locked_inverse_inertia(mean_inverse_inertia, 0, rb);
+        mean_inverse_inertia[0] *= scratch_share[1];
+        mean_inverse_inertia[1] *= scratch_share[1];
+        mean_inverse_inertia[2] *= scratch_share[1];
+
+        this.__mean_inverse_mass = mean_inverse_mass;
+
         const qx = tr.rotation_x, qy = tr.rotation_y, qz = tr.rotation_z, qw = tr.rotation_w;
         const px = tr.translation_x, py = tr.translation_y, pz = tr.translation_z;
-        const lv = rb.linearVelocity, av = rb.angularVelocity;
-        let drivenCount = 0;
-        for (let i = 0; i < this.wheels.length; i++) {
-            if (this.wheels[i].driven) drivenCount++;
-        }
-        this.__drivenCount = drivenCount;
+        let drivenCount = 0;
+        for (let i = 0; i < wheel_count; i++) {
+            if (wheels[i].driven) drivenCount++;
+        }
+        this.__drivenCount = drivenCount;
         const drivePer = drivenCount > 0 ? this.__driveForce / drivenCount : 0;
 
-        for (let wi = 0; wi < this.wheels.length; wi++) {
-            const w = this.wheels[wi];
+        const wheel_frame = this.__wheel_frame;
+        const wheel_lever = this.__wheel_lever;
+        const wheel_rolls = this.__wheel_rolls;
+        const wheel_tyre = this.__wheel_tyre;
+        const wheel_budget = this.__wheel_budget;
+        const row_wheel = this.__row_wheel;
+        const row_compliance = this.__row_compliance;
+        const row_restore = this.__row_restore;
+        const row_upper = this.__row_upper;
+
+        scratch_spring_params[2] = dt;
+
+        let rows = 0;
+
+        // --- Suspension rays: each grounded wheel whose spring works is a row of the spring solve ---
+        for (let wi = 0; wi < wheel_count; wi++) {
+            const w = wheels[wi];
+
+            wheel_budget[wi] = 0;
 
             // World mount point and suspension axis.
             v3_quaternion_apply(scratch_v, 0, w.localPosition[0], w.localPosition[1], w.localPosition[2], qx, qy, qz, qw);
@@ -276,12 +674,15 @@ export class RaycastVehicle {
                 w.compression = 0;
                 w.contactBodyId = -1; // documented no-contact sentinel
                 w.forwardSpeed = 0;
+                wheel_tyre[wi * 2] = 0;
+                wheel_tyre[wi * 2 + 1] = 0;
                 continue;
             }
 
             const t = this.__hit.t;
             w.inContact = true;
             w.contactBodyId = this.__hit.body_id;
+            w.suspensionForce = 0;
             w.suspensionLength = t - w.radius;
             if (w.suspensionLength < 0) w.suspensionLength = 0;
             w.compression = w.suspensionRestLength - w.suspensionLength;
@@ -294,26 +695,10 @@ export class RaycastVehicle {
             w.contactPoint[0] = cx; w.contactPoint[1] = cy; w.contactPoint[2] = cz;
             w.contactNormal[0] = nx; w.contactNormal[1] = ny; w.contactNormal[2] = nz;
 
-            // Velocity of the chassis at the contact point.
-            const rx = cx - px, ry = cy - py, rz = cz - pz;
-            const vptx = lv[0] + av[1] * rz - av[2] * ry;
-            const vpty = lv[1] + av[2] * rx - av[0] * rz;
-            const vptz = lv[2] + av[0] * ry - av[1] * rx;
-
-            // --- Suspension: spring + damper along the contact normal ---
-            const projVel = vptx * nx + vpty * ny + vptz * nz; // closing speed along normal
-            let susForce = w.suspensionStiffness * w.compression - w.suspensionDamping * projVel;
-            if (susForce < 0) susForce = 0;
-            else if (susForce > w.suspensionMaxForce) susForce = w.suspensionMaxForce;
-            w.suspensionForce = susForce;
-
-            if (susForce !== 0) {
-                v3_set(this.__force, 0, nx * susForce, ny * susForce, nz * susForce);
-                this.__point[0] = cx; this.__point[1] = cy; this.__point[2] = cz;
-                this.system.applyForceAt(rb, tr, this.__force, this.__point);
-            }
+            const l = wi * 3;
+            wheel_lever[l] = cx - px; wheel_lever[l + 1] = cy - py; wheel_lever[l + 2] = cz - pz;
 
-            // --- Tyre friction: forward / side basis in the contact plane ---
+            // Forward / side basis in the contact plane.
             v3_quaternion_apply(scratch_v, 0, w.localForward[0], w.localForward[1], w.localForward[2], qx, qy, qz, qw);
             let fwx = scratch_v[0], fwy = scratch_v[1], fwz = scratch_v[2];
             if (w.steering !== 0) {
@@ -322,54 +707,594 @@ export class RaycastVehicle {
                 fwx = scratch_v[0]; fwy = scratch_v[1]; fwz = scratch_v[2];
             }
             // Project forward onto the contact plane, normalise.
-            let fdotn = fwx * nx + fwy * ny + fwz * nz;
+            const fdotn = fwx * nx + fwy * ny + fwz * nz;
             fwx -= fdotn * nx; fwy -= fdotn * ny; fwz -= fdotn * nz;
-            let fl = v3_length(fwx, fwy, fwz);
-            if (fl < 1e-6) continue; // degenerate (forward parallel to normal)
-            fwx /= fl; fwy /= fl; fwz /= fl;
-            // Side = normal × forward (already unit & in-plane).
-            const sx = ny * fwz - nz * fwy;
-            const sy = nz * fwx - nx * fwz;
-            const sz = nx * fwy - ny * fwx;
-
-            const fwdVel = vptx * fwx + vpty * fwy + vptz * fwz;
-            const sideVel = vptx * sx + vpty * sy + vptz * sz;
-            w.forwardSpeed = fwdVel;
-
-            // Lateral grip: impulse that cancels the side velocity.
-            const denomSide = effective_mass(rb, tr, invMass, rx, ry, rz, sx, sy, sz);
-            let jSide = denomSide > 0 ? -sideVel / denomSide : 0;
-
-            // Longitudinal: engine drive minus brake (brake never reverses).
-            let jFwd = w.driven ? drivePer * dt : 0;
-            if (this.__brakeForce > 0 && fwdVel !== 0) {
-                const denomFwd = effective_mass(rb, tr, invMass, rx, ry, rz, fwx, fwy, fwz);
-                const stopImpulse = denomFwd > 0 ? Math.abs(fwdVel) / denomFwd : 0;
-                const brakeImpulse = Math.min(this.__brakeForce * dt, stopImpulse);
-                jFwd -= Math.sign(fwdVel) * brakeImpulse;
+            const fl = v3_length(fwx, fwy, fwz);
+            const rolls = fl >= 1e-6; // forward along the normal: the tyre can neither roll nor grip
+            if (rolls) {
+                fwx /= fl; fwy /= fl; fwz /= fl;
             }
 
-            // Friction circle: clamp the combined tyre impulse to μ·N·dt.
-            const budget = w.friction * susForce * dt;
-            const mag = Math.sqrt(jFwd * jFwd + jSide * jSide);
-            if (mag > budget && mag > 0) {
-                const scale = budget / mag;
-                jFwd *= scale; jSide *= scale;
+            const f = wi * 9;
+            wheel_frame[f + FRAME_NORMAL] = nx;
+            wheel_frame[f + FRAME_NORMAL + 1] = ny;
+            wheel_frame[f + FRAME_NORMAL + 2] = nz;
+            wheel_frame[f + FRAME_FORWARD] = fwx;
+            wheel_frame[f + FRAME_FORWARD + 1] = fwy;
+            wheel_frame[f + FRAME_FORWARD + 2] = fwz;
+            // Side = normal × forward (already unit & in-plane).
+            wheel_frame[f + FRAME_SIDE] = ny * fwz - nz * fwy;
+            wheel_frame[f + FRAME_SIDE + 1] = nz * fwx - nx * fwz;
+            wheel_frame[f + FRAME_SIDE + 2] = nx * fwy - ny * fwx;
+            wheel_rolls[wi] = rolls ? 1 : 0;
+
+            scratch_spring_params[0] = w.suspensionStiffness;
+            scratch_spring_params[1] = w.suspensionDamping;
+            if (!soft_spring_coefficients(scratch_spring, 0, scratch_spring_params, 0)) {
+                continue; // no stiffness and no damping: the spring pushes nothing, so the tyre grips nothing
             }
 
-            if (jFwd !== 0 || jSide !== 0) {
-                v3_set(
-                    this.__force, 0,
-                    fwx * jFwd + sx * jSide,
-                    fwy * jFwd + sy * jSide,
-                    fwz * jFwd + sz * jSide
+            // A spring: J·v̄⁺ + β·C + γ·λ = 0 with C = −compression, so (J·M⁻¹·Jᵀ + γ)·λ = β·compression − J·v̄.
+            row_wheel[rows] = wi;
+            row_compliance[rows] = scratch_spring[0];
+            row_restore[rows] = scratch_spring[1] * w.compression;
+            row_upper[rows] = w.suspensionMaxForce * dt;
+            rows++;
+        }
+
+        const mean_linear = this.__mean_linear;
+        const mean_angular = this.__mean_angular;
+
+        if (rows > 0) {
+            this.__prepare_springs(rows);
+
+            // Each tyre's friction circle, from the push its spring gives with every tyre pushing as it did
+            // the step before.
+            this.system.predictStepMeanVelocity(mean_linear, mean_angular, rb, tr, dt);
+
+            for (let r = 0; r < rows; r++) {
+                const wi = row_wheel[r];
+
+                if (wheel_rolls[wi] === 0) {
+                    continue;
+                }
+
+                const forward = wheel_tyre[wi * 2];
+                const side = wheel_tyre[wi * 2 + 1];
+
+                if (forward === 0 && side === 0) {
+                    continue;
+                }
+
+                const f = wi * 9;
+                const jx = wheel_frame[f + FRAME_FORWARD] * forward + wheel_frame[f + FRAME_SIDE] * side;
+                const jy = wheel_frame[f + FRAME_FORWARD + 1] * forward + wheel_frame[f + FRAME_SIDE + 1] * side;
+                const jz = wheel_frame[f + FRAME_FORWARD + 2] * forward + wheel_frame[f + FRAME_SIDE + 2] * side;
+
+                const l = wi * 3;
+                const rx = wheel_lever[l], ry = wheel_lever[l + 1], rz = wheel_lever[l + 2];
+
+                mean_linear[0] += jx * mean_inverse_mass;
+                mean_linear[1] += jy * mean_inverse_mass;
+                mean_linear[2] += jz * mean_inverse_mass;
+
+                world_inverse_inertia_apply_raw(
+                    scratch_v, 0,
+                    mean_inverse_inertia[0], mean_inverse_inertia[1], mean_inverse_inertia[2],
+                    qx, qy, qz, qw,
+                    ry * jz - rz * jy, rz * jx - rx * jz, rx * jy - ry * jx
                 );
-                this.__point[0] = cx; this.__point[1] = cy; this.__point[2] = cz;
-                this.system.applyImpulseAt(rb, tr, this.__force, this.__point);
+
+                mean_angular[0] += scratch_v[0];
+                mean_angular[1] += scratch_v[1];
+                mean_angular[2] += scratch_v[2];
+            }
+
+            this.__solve_springs(rows);
+
+            const impulse = this.__row_impulse;
+            for (let r = 0; r < rows; r++) {
+                const wi = row_wheel[r];
+                wheel_budget[wi] = wheels[wi].friction * impulse[r];
+            }
+
+            this.__prepare_tyres(rows);
+        }
+
+        // --- Tyre friction, against the step's motion with the springs answering ---
+        const wheel_brake = this.__wheel_brake;
+        const brake_limit = this.__brakeForce * dt;
+
+        // Each tyre starts from the impulse it applied the step before, within this step's brake and
+        // friction circle.
+        for (let wi = 0; wi < wheel_count; wi++) {
+            const w = wheels[wi];
+
+            const side_before = wheel_tyre[wi * 2 + 1];
+
+            wheel_tyre[wi * 2] = 0;
+            wheel_tyre[wi * 2 + 1] = 0;
+
+            if (!w.inContact || wheel_rolls[wi] === 0) {
+                wheel_brake[wi] = 0;
+                continue;
+            }
+
+            const budget = wheel_budget[wi];
+
+            if (budget <= 0) {
+                wheel_brake[wi] = 0; // nothing pushes the patch into the ground, so it grips nothing
+                continue;
+            }
+
+            const brake = wheel_brake[wi];
+
+            scratch_grip[0] = w.driven ? drivePer * dt : 0;
+            scratch_grip[1] = brake < -brake_limit ? -brake_limit : (brake > brake_limit ? brake_limit : brake);
+            scratch_grip[2] = side_before;
+            this.__grip(wi);
+        }
+
+        // Each in turn cancels its patch's slip in that motion: across with grip, along with the brake, up
+        // to its force.
+        if (rows > 0) {
+            const ml = this.__mean_linear;
+            const ma = this.__mean_angular;
+            const wheel_block = this.__wheel_block;
+
+            for (let wi = 0; wi < wheel_count; wi++) {
+                const w = wheels[wi];
+
+                if (!w.inContact || wheel_rolls[wi] === 0 || wheel_budget[wi] <= 0) {
+                    continue;
+                }
+
+                const l = wi * 3;
+                const rx = wheel_lever[l], ry = wheel_lever[l + 1], rz = wheel_lever[l + 2];
+
+                // The patch's velocity in the chassis' mean motion across the step.
+                const ux = ml[0] + ma[1] * rz - ma[2] * ry;
+                const uy = ml[1] + ma[2] * rx - ma[0] * rz;
+                const uz = ml[2] + ma[0] * ry - ma[1] * rx;
+
+                const f = wi * 9;
+                const forward_slip = ux * wheel_frame[f + FRAME_FORWARD] + uy * wheel_frame[f + FRAME_FORWARD + 1] + uz * wheel_frame[f + FRAME_FORWARD + 2];
+                const side_slip = ux * wheel_frame[f + FRAME_SIDE] + uy * wheel_frame[f + FRAME_SIDE + 1] + uz * wheel_frame[f + FRAME_SIDE + 2];
+
+                // Both at once: the impulses `K⁻¹·slip`, `K` this wheel's block of `J·W·Jᵀ`. With the brake at
+                // its force, the side cancels what the brake's change leaves.
+                const b = wi * 3;
+                const k_forward = wheel_block[b];
+                const k_side = wheel_block[b + 1];
+                const k_coupling = wheel_block[b + 2];
+
+                let brake = 0;
+
+                if (brake_limit > 0) {
+                    const determinant = k_forward * k_side - k_coupling * k_coupling;
+                    brake = wheel_brake[wi] - (determinant > 0 ? (k_side * forward_slip - k_coupling * side_slip) / determinant : 0);
+                    brake = brake < -brake_limit ? -brake_limit : (brake > brake_limit ? brake_limit : brake);
+                }
+
+                const brake_change = brake - wheel_brake[wi];
+
+                scratch_grip[0] = w.driven ? drivePer * dt : 0;
+                scratch_grip[1] = brake;
+                scratch_grip[2] = wheel_tyre[wi * 2 + 1] - (k_side > 0 ? (side_slip + k_coupling * brake_change) / k_side : 0);
+                this.__grip(wi);
+            }
+        }
+
+        // Each wheel's ground speed: its contact's in the step's mean motion, every impulse above in it.
+        if (rows === 0) {
+            this.system.predictStepMeanVelocity(mean_linear, mean_angular, rb, tr, dt);
+        }
+
+        for (let wi = 0; wi < wheel_count; wi++) {
+            const w = wheels[wi];
+
+            if (!w.inContact) {
+                continue;
+            }
+
+            const l = wi * 3;
+            const rx = wheel_lever[l], ry = wheel_lever[l + 1], rz = wheel_lever[l + 2];
+
+            const f = wi * 9 + FRAME_FORWARD;
+            w.forwardSpeed = (mean_linear[0] + mean_angular[1] * rz - mean_angular[2] * ry) * wheel_frame[f]
+                + (mean_linear[1] + mean_angular[2] * rx - mean_angular[0] * rz) * wheel_frame[f + 1]
+                + (mean_linear[2] + mean_angular[0] * ry - mean_angular[1] * rx) * wheel_frame[f + 2];
+
+            // Visual wheel spin: the ground the contact covers over the step.
+            if (w.radius > 0) w.rotation += (w.forwardSpeed / w.radius) * dt;
+        }
+
+        // --- The springs, against where the step now carries the chassis, the tyres' impulses in it ---
+        if (rows > 0) {
+            this.system.predictStepMeanVelocity(mean_linear, mean_angular, rb, tr, dt);
+            this.__solve_springs(rows);
+
+            const impulse = this.__row_impulse;
+            const jacobian = this.__row_jacobian;
+            const out = this.__impulse;
+
+            for (let r = 0; r < rows; r++) {
+                const w = wheels[row_wheel[r]];
+                const lambda = impulse[r];
+
+                w.suspensionForce = lambda / dt;
+
+                if (lambda > 0) {
+                    const j = r * 6;
+                    v3_set(out, 0, jacobian[j] * lambda, jacobian[j + 1] * lambda, jacobian[j + 2] * lambda);
+                    this.system.applyImpulseAt(rb, tr, out, w.contactPoint);
+                }
+            }
+        }
+    }
+
+    /**
+     * Fill the `rows` springs' Jacobians, the chassis' angular response to each, and the matrix
+     * `J·M⁻¹·Jᵀ` with each spring's compliance on its diagonal — all fixed by the pose, so shared by
+     * every solve of the step.
+     * @param {number} rows
+     * @private
+     */
+    __prepare_springs(rows) {
+        const tr = this.chassisTransform;
+        const inverse_mass = this.__mean_inverse_mass;
+        const inverse_inertia = this.__mean_inverse_inertia;
+        const frame = this.__wheel_frame;
+        const lever = this.__wheel_lever;
+        const row_wheel = this.__row_wheel;
+        const jacobian = this.__row_jacobian;
+        const response = this.__row_response;
+        const compliance = this.__row_compliance;
+        const matrix = this.__row_matrix;
+
+        for (let r = 0; r < rows; r++) {
+            const wi = row_wheel[r];
+
+            const f = wi * 9 + FRAME_NORMAL;
+            const nx = frame[f], ny = frame[f + 1], nz = frame[f + 2];
+
+            const l = wi * 3;
+            const rx = lever[l], ry = lever[l + 1], rz = lever[l + 2];
+
+            const ax = ry * nz - rz * ny;
+            const ay = rz * nx - rx * nz;
+            const az = rx * ny - ry * nx;
+
+            const j = r * 6;
+            jacobian[j] = nx;
+            jacobian[j + 1] = ny;
+            jacobian[j + 2] = nz;
+            jacobian[j + 3] = ax;
+            jacobian[j + 4] = ay;
+            jacobian[j + 5] = az;
+
+            world_inverse_inertia_apply_raw(
+                response, r * 3,
+                inverse_inertia[0], inverse_inertia[1], inverse_inertia[2],
+                tr.rotation_x, tr.rotation_y, tr.rotation_z, tr.rotation_w,
+                ax, ay, az
+            );
+        }
+
+        for (let i = 0; i < rows; i++) {
+            const ji = i * 6;
+
+            for (let k = i; k < rows; k++) {
+                const jk = k * 6;
+                const rk = k * 3;
+
+                const value = inverse_mass * (
+                        jacobian[ji] * jacobian[jk]
+                        + jacobian[ji + 1] * jacobian[jk + 1]
+                        + jacobian[ji + 2] * jacobian[jk + 2]
+                    )
+                    + jacobian[ji + 3] * response[rk]
+                    + jacobian[ji + 4] * response[rk + 1]
+                    + jacobian[ji + 5] * response[rk + 2];
+
+                matrix[k * rows + i] = value;
+                matrix[i * rows + k] = value;
             }
 
-            // Visual wheel spin from forward ground speed.
-            if (w.radius > 0) w.rotation += (fwdVel / w.radius) * dt;
+            matrix[i * rows + i] += compliance[i];
+        }
+    }
+
+    /**
+     * Solve the `rows` prepared springs as one backward-Euler step against the chassis' mean motion in
+     * {@link __mean_linear} / {@link __mean_angular}, into {@link __row_impulse}: each pushes, and no
+     * harder than its most force.
+     * @param {number} rows
+     * @private
+     */
+    __solve_springs(rows) {
+        const jacobian = this.__row_jacobian;
+        const restore = this.__row_restore;
+        const rhs = this.__row_rhs;
+        const ml = this.__mean_linear;
+        const ma = this.__mean_angular;
+
+        for (let r = 0; r < rows; r++) {
+            const j = r * 6;
+
+            // The chassis' speed away from the ground at the contact, across the step: n·v̄ + (r × n)·ω̄.
+            const separating = jacobian[j] * ml[0] + jacobian[j + 1] * ml[1] + jacobian[j + 2] * ml[2]
+                + jacobian[j + 3] * ma[0] + jacobian[j + 4] * ma[1] + jacobian[j + 5] * ma[2];
+
+            rhs[r] = restore[r] - separating;
+        }
+
+        solve_box_constrained_qp(this.__row_matrix, rhs, this.__row_lower, this.__row_upper, this.__row_impulse, rows);
+    }
+
+    /**
+     * Ready the tyres' solve, after the springs are solved against the tyres pushing as they did the step
+     * before. Factors the springs that push freely in that solve, which answer the tyres; turns the motion
+     * in {@link __mean_linear} / {@link __mean_angular} into the step's with those springs pushing and no
+     * tyre; and works out each tyre's response, `W·Jᵀ` and `J·W·Jᵀ`.
+     * @param {number} rows
+     * @private
+     */
+    __prepare_tyres(rows) {
+        const inverse_mass = this.__mean_inverse_mass;
+        const impulse = this.__row_impulse;
+        const lower = this.__row_lower;
+        const upper = this.__row_upper;
+        const matrix = this.__row_matrix;
+        const jacobian = this.__row_jacobian;
+        const response = this.__row_response;
+        const free_row = this.__free_row;
+        const free_matrix = this.__free_matrix;
+
+        // A spring between its bounds answers a tyre's push; one at a bound holds its impulse.
+        let free_count = 0;
+        let diagonal_max = 0;
+
+        for (let r = 0; r < rows; r++) {
+            const lambda = impulse[r];
+
+            if (lambda > lower[r] && lambda < upper[r]) {
+                free_row[free_count++] = r;
+
+                const d = matrix[r * rows + r];
+
+                if (d > diagonal_max) {
+                    diagonal_max = d;
+                }
+            }
+        }
+
+        // lu_factor_linear_system refuses a pivot under an absolute 1e-12; with the largest diagonal scaled
+        // to one, that is relative to the block.
+        const scale = diagonal_max > 0 ? 1 / diagonal_max : 1;
+
+        for (let a = 0; a < free_count; a++) {
+            const row = free_row[a];
+
+            for (let b = 0; b < free_count; b++) {
+                free_matrix[b * free_count + a] = matrix[free_row[b] * rows + row] * scale;
+            }
+        }
+
+        // Positive definite, a compliance on every diagonal; should it still not factor, the tyres see the
+        // chassis without the springs answering.
+        if (free_count > 0 && !lu_factor_linear_system(free_matrix, this.__free_pivot, free_count)) {
+            free_count = 0;
+        }
+
+        this.__free_count = free_count;
+        this.__free_scale = scale;
+
+        // The springs' push in the step's motion.
+        const ml = this.__mean_linear;
+        const ma = this.__mean_angular;
+
+        for (let r = 0; r < rows; r++) {
+            const lambda = impulse[r];
+            const j = r * 6;
+            const k = r * 3;
+
+            ml[0] += jacobian[j] * lambda * inverse_mass;
+            ml[1] += jacobian[j + 1] * lambda * inverse_mass;
+            ml[2] += jacobian[j + 2] * lambda * inverse_mass;
+
+            ma[0] += response[k] * lambda;
+            ma[1] += response[k + 1] * lambda;
+            ma[2] += response[k + 2] * lambda;
+        }
+
+        // Each tyre's response; and out with the push the spring solve took it to give.
+        const row_wheel = this.__row_wheel;
+        const rolls = this.__wheel_rolls;
+        const tyre = this.__wheel_tyre;
+        const wheel_response = this.__wheel_response;
+        const lever = this.__wheel_lever;
+        const frame = this.__wheel_frame;
+
+        for (let r = 0; r < rows; r++) {
+            const wi = row_wheel[r];
+
+            if (rolls[wi] === 0) {
+                continue;
+            }
+
+            this.__tyre_response(wi, FRAME_FORWARD);
+            this.__tyre_response(wi, FRAME_SIDE);
+
+            const o = wi * 12;
+
+            // The coupling, `J_f·W·J_sᵀ`: the patch's forward speed per unit side impulse.
+            const rx = lever[wi * 3], ry = lever[wi * 3 + 1], rz = lever[wi * 3 + 2];
+            const s = o + 6;
+            const f = wi * 9 + FRAME_FORWARD;
+
+            this.__wheel_block[wi * 3 + 2] =
+                (wheel_response[s] + wheel_response[s + 4] * rz - wheel_response[s + 5] * ry) * frame[f]
+                + (wheel_response[s + 1] + wheel_response[s + 5] * rx - wheel_response[s + 3] * rz) * frame[f + 1]
+                + (wheel_response[s + 2] + wheel_response[s + 3] * ry - wheel_response[s + 4] * rx) * frame[f + 2];
+
+            const forward = tyre[wi * 2];
+            const side = tyre[wi * 2 + 1];
+
+            for (let i = 0; i < 3; i++) {
+                ml[i] -= wheel_response[o + i] * forward + wheel_response[o + 6 + i] * side;
+                ma[i] -= wheel_response[o + 3 + i] * forward + wheel_response[o + 9 + i] * side;
+            }
+        }
+    }
+
+    /**
+     * The chassis' mean velocity across the step per unit impulse along wheel `wi`'s forward or side
+     * direction at its contact, the free springs answering: `W·Jᵀ`, linear then angular, into
+     * {@link __wheel_response}, and `J·W·Jᵀ`, the change of the contact's speed along that direction per
+     * unit impulse, into its diagonal of {@link __wheel_block}.
+     * @param {number} wi
+     * @param {number} direction {@link FRAME_FORWARD} or {@link FRAME_SIDE}
+     * @private
+     */
+    __tyre_response(wi, direction) {
+        const tr = this.chassisTransform;
+        const inverse_mass = this.__mean_inverse_mass;
+        const inverse_inertia = this.__mean_inverse_inertia;
+
+        const lever = this.__wheel_lever;
+        const rx = lever[wi * 3], ry = lever[wi * 3 + 1], rz = lever[wi * 3 + 2];
+
+        const frame = this.__wheel_frame;
+        const f = wi * 9 + direction;
+        const dx = frame[f], dy = frame[f + 1], dz = frame[f + 2];
+
+        const ax = ry * dz - rz * dy;
+        const ay = rz * dx - rx * dz;
+        const az = rx * dy - ry * dx;
+
+        // M⁻¹·Jᵀ: the free chassis.
+        world_inverse_inertia_apply_raw(
+            scratch_v, 0,
+            inverse_inertia[0], inverse_inertia[1], inverse_inertia[2],
+            tr.rotation_x, tr.rotation_y, tr.rotation_z, tr.rotation_w,
+            ax, ay, az
+        );
+
+        let vx = dx * inverse_mass, vy = dy * inverse_mass, vz = dz * inverse_mass;
+        let wx = scratch_v[0], wy = scratch_v[1], wz = scratch_v[2];
+        let denominator = dx * vx + dy * vy + dz * vz + ax * wx + ay * wy + az * wz;
+
+        const free_count = this.__free_count;
+
+        if (free_count > 0) {
+            const free_row = this.__free_row;
+            const jacobian = this.__row_jacobian;
+            const response = this.__row_response;
+            const speed = this.__free_speed;
+            const answer = this.__free_answer;
+            const scale = this.__free_scale;
+
+            for (let a = 0; a < free_count; a++) {
+                const j = free_row[a] * 6;
+
+                const s = jacobian[j] * vx + jacobian[j + 1] * vy + jacobian[j + 2] * vz
+                    + jacobian[j + 3] * wx + jacobian[j + 4] * wy + jacobian[j + 5] * wz;
+
+                speed[a] = s;
+                answer[a] = s * scale;
+            }
+
+            lu_solve_linear_system(this.__free_matrix, this.__free_pivot, answer, free_count);
+
+            // Less each free spring's push.
+            for (let a = 0; a < free_count; a++) {
+                const r = free_row[a];
+                const y = answer[a];
+                const j = r * 6;
+                const k = r * 3;
+
+                denominator -= speed[a] * y;
+
+                vx -= jacobian[j] * y * inverse_mass;
+                vy -= jacobian[j + 1] * y * inverse_mass;
+                vz -= jacobian[j + 2] * y * inverse_mass;
+
+                wx -= response[k] * y;
+                wy -= response[k + 1] * y;
+                wz -= response[k + 2] * y;
+            }
+        }
+
+        const along_side = direction === FRAME_SIDE ? 1 : 0;
+        const out = this.__wheel_response;
+        const offset = wi * 12 + along_side * 6;
+
+        out[offset] = vx;
+        out[offset + 1] = vy;
+        out[offset + 2] = vz;
+        out[offset + 3] = wx;
+        out[offset + 4] = wy;
+        out[offset + 5] = wz;
+
+        this.__wheel_block[wi * 3 + along_side] = denominator;
+    }
+
+    /**
+     * Set wheel `wi`'s tyre impulse for the step from {@link scratch_grip}'s drive, brake and side:
+     * `drive + brake` along its forward direction and `side` along its side, clamped together to its
+     * friction circle. The change applies to the chassis, and to its motion in {@link __mean_linear} /
+     * {@link __mean_angular} with the free springs answering.
+     * @param {number} wi
+     * @private
+     */
+    __grip(wi) {
+        const tyre = this.__wheel_tyre;
+        const budget = this.__wheel_budget[wi];
+
+        const drive = scratch_grip[0];
+        let forward = drive + scratch_grip[1];
+        let side = scratch_grip[2];
+
+        const magnitude = Math.sqrt(forward * forward + side * side);
+
+        if (magnitude > budget) {
+            const s = budget / magnitude;
+            forward *= s;
+            side *= s;
+        }
+
+        this.__wheel_brake[wi] = forward - drive;
+
+        const d_forward = forward - tyre[wi * 2];
+        const d_side = side - tyre[wi * 2 + 1];
+
+        tyre[wi * 2] = forward;
+        tyre[wi * 2 + 1] = side;
+
+        if (d_forward === 0 && d_side === 0) {
+            return;
+        }
+
+        const frame = this.__wheel_frame;
+        const f = wi * 9;
+
+        v3_set(
+            this.__impulse, 0,
+            frame[f + FRAME_FORWARD] * d_forward + frame[f + FRAME_SIDE] * d_side,
+            frame[f + FRAME_FORWARD + 1] * d_forward + frame[f + FRAME_SIDE + 1] * d_side,
+            frame[f + FRAME_FORWARD + 2] * d_forward + frame[f + FRAME_SIDE + 2] * d_side
+        );
+        this.system.applyImpulseAt(this.chassisBody, this.chassisTransform, this.__impulse, this.wheels[wi].contactPoint);
+
+        const response = this.__wheel_response;
+        const o = wi * 12;
+        const ml = this.__mean_linear;
+        const ma = this.__mean_angular;
+
+        for (let i = 0; i < 3; i++) {
+            ml[i] += response[o + i] * d_forward + response[o + 6 + i] * d_side;
+            ma[i] += response[o + 3 + i] * d_forward + response[o + 9 + i] * d_side;
         }
     }
 }