@woosh/meep-engine 3.30.0 → 3.31.0

package/src/engine/physics/queries/shape_cast.js

@@ -384,195 +384,209 @@ export function shape_cast(system, ray, shape, rotation, result, filter = return
     let best_t = tMax;
     let best_body_id = -1;
     let best_entity = -1;
+    /** Winning collider and the transform it was posed at, for the normal probe. */
+    let best_collider = null;
+    let best_tr = null;
 
-    for (let i = 0; i < n_total; i++) {
+    candidates: for (let i = 0; i < n_total; i++) {
         const body_id = scratch_candidates[i];
         const body_idx = body_id_index(body_id);
         const entity = system.entityOf(body_id);
         if (entity < 0) continue;
 
-        const collider = system.__primary_collider(body_idx);
-        if (collider === null) continue;
-        if (!filter(entity, collider, body_id)) continue;
+        const colliders = system.__body_collider_lists[body_idx];
+        if (colliders === undefined) continue;
+
+        // Every collider is posed at its OWN world transform — a compound
+        // body's collider can live on a child entity metres from the body's
+        // pose, and that is the transform its broadphase leaf was built from.
+        for (let ci = 0; ci < colliders.length; ci++) {
+            const collider = colliders[ci].collider;
+            if (!filter(entity, collider, body_id)) continue;
+
+            const target_tr = colliders[ci].transform;
+            candidate_posed.setup_components(
+                    collider.shape,
+                    target_tr.translation_x, target_tr.translation_y, target_tr.translation_z,
+                    target_tr.rotation_x, target_tr.rotation_y, target_tr.rotation_z, target_tr.rotation_w
+                );
 
-        const target_tr = system.__transforms[body_idx];
-        candidate_posed.setup_components(
-                collider.shape,
+            // Already overlapping at t = 0? The bisection's "no overlap at lo,
+            // overlap at hi" invariant doesn't hold for this candidate. Under CCD
+            // semantics it is a resting contact to step over — skip THIS candidate
+            // only, and keep scanning for real blockers.
+            //
+            // Under kinematic semantics targets are SOLID: a shape that starts
+            // genuinely inside one is blocked where it stands, `t = 0`, whatever
+            // direction it is trying to sweep. Nothing can beat that, so stop
+            // scanning. Getting out is depenetration's job, not the sweep's.
+            //
+            // Exact TANGENCY is the exception, and it needs one. A zero-depth
+            // touch is not "inside" anything — the shape is resting against a
+            // face, or flush with a brush seam, and is free to slide along it or
+            // leave. It also survives depenetration, which has no depth to push
+            // out of, so it persists frame after frame.
+            //
+            // Reporting it as a `t = 0` hit ends the scan, and that is the whole
+            // problem: the caller is handed a contact it correctly judges harmless
+            // for this direction and concludes the sweep is clear, while the body
+            // it was actually about to hit was never tested. A character flush
+            // against a wall falls through the floor that way. So a tangency
+            // blocks only when the sweep drives INTO it, and otherwise steps aside
+            // and lets the scan continue.
+            //
+            // MPR's depth at the START pose is what separates the two: positive
+            // means genuine overlap, none means tangency. Tangency is also exactly
+            // where the normal is hardest to recover, hence the second probe; if
+            // even that degenerates there is no normal to judge with and the
+            // contact blocks, stopping short being the safe failure.
+            swept_posed.px = ox; swept_posed.py = oy; swept_posed.pz = oz;
+            if (gjk(simplex_buf, swept_posed, candidate_posed)) {
+                if (skip_initial_overlaps) continue;
+
+                // The tangency exception reads MPR's depth and normal, both of
+                // which assume a convex target. This query has never supported
+                // concave ones (`overlap_shape` decomposes them per-triangle;
+                // nothing here does), so rather than extend a convex-only
+                // inference to geometry the module cannot see properly, leave
+                // those on the unconditional "solid, blocked at t = 0" path.
+                const convex_target = collider.shape.is_convex !== false;
+                if (convex_target && !probe_contact_normal(probe_normal, ox, oy, oz, target_tr)) {
+                    const known = recover_contact_normal(
+                        probe_normal, ox, oy, oz, dx, dy, dz, target_tr,
+                    );
+                    if (known) {
+                        // Both vectors are unit, so this is the sine of the angle
+                        // between the sweep and the contact plane. Zero means
+                        // exactly parallel — sliding along the face — and positive
+                        // means leaving it; neither blocks. The tolerance matters
+                        // because the parallel case sits right on the sign change,
+                        // and an MPR-recovered normal carries ~1e-6 of angular
+                        // noise: without it a sweep ALONG a face flips to
+                        // "head-on" on solver noise alone.
+                        const into = dx * probe_normal[0] + dy * probe_normal[1] + dz * probe_normal[2];
+                        if (into > -GRAZING_SINE_EPSILON) continue;
+                    }
+                }
+
+                best_t = 0;
+                best_body_id = body_id;
+                best_entity = entity;
+                best_collider = collider;
+                best_tr = target_tr;
+                break candidates;
+            }
+
+            // ── Slab intersection: narrow the search interval analytically ─
+            //
+            // Compute the body's tight world AABB and intersect it with the
+            // swept shape's AABB sliding along the sweep direction. The
+            // result is the t-interval `[t_aabb_enter, t_aabb_exit]` during
+            // which the two AABBs overlap. Outside this interval the actual
+            // shapes can't overlap either (AABB is a superset of the
+            // shape), so we get to skip all of [0, t_aabb_enter) and
+            // (t_aabb_exit, best_t] without testing.
+            //
+            // This is the key to making `shapeCast` scale to long sweeps:
+            // a 1 km cast of a 1 m sphere against another 1 m sphere has an
+            // AABB-overlap window of ≈ 2 m (the sum of diameters along the
+            // sweep axis), reducing the coarse-step grid from a 30 m
+            // resolution (1000/32) to 6 cm (2/32).
+            collider.shape.compute_bounding_box(target_local_aabb);
+            aabb3_transform_oriented(
+                target_world_aabb, 0,
+                target_local_aabb[0], target_local_aabb[1], target_local_aabb[2],
+                target_local_aabb[3], target_local_aabb[4], target_local_aabb[5],
                 target_tr.translation_x, target_tr.translation_y, target_tr.translation_z,
                 target_tr.rotation_x, target_tr.rotation_y, target_tr.rotation_z, target_tr.rotation_w
             );
 
-        // Already overlapping at t = 0? The bisection's "no overlap at lo,
-        // overlap at hi" invariant doesn't hold for this candidate. Under CCD
-        // semantics it is a resting contact to step over — skip THIS candidate
-        // only, and keep scanning for real blockers.
-        //
-        // Under kinematic semantics targets are SOLID: a shape that starts
-        // genuinely inside one is blocked where it stands, `t = 0`, whatever
-        // direction it is trying to sweep. Nothing can beat that, so stop
-        // scanning. Getting out is depenetration's job, not the sweep's.
-        //
-        // Exact TANGENCY is the exception, and it needs one. A zero-depth
-        // touch is not "inside" anything — the shape is resting against a
-        // face, or flush with a brush seam, and is free to slide along it or
-        // leave. It also survives depenetration, which has no depth to push
-        // out of, so it persists frame after frame.
-        //
-        // Reporting it as a `t = 0` hit ends the scan, and that is the whole
-        // problem: the caller is handed a contact it correctly judges harmless
-        // for this direction and concludes the sweep is clear, while the body
-        // it was actually about to hit was never tested. A character flush
-        // against a wall falls through the floor that way. So a tangency
-        // blocks only when the sweep drives INTO it, and otherwise steps aside
-        // and lets the scan continue.
-        //
-        // MPR's depth at the START pose is what separates the two: positive
-        // means genuine overlap, none means tangency. Tangency is also exactly
-        // where the normal is hardest to recover, hence the second probe; if
-        // even that degenerates there is no normal to judge with and the
-        // contact blocks, stopping short being the safe failure.
-        swept_posed.px = ox; swept_posed.py = oy; swept_posed.pz = oz;
-        if (gjk(simplex_buf, swept_posed, candidate_posed)) {
-            if (skip_initial_overlaps) continue;
-
-            // The tangency exception reads MPR's depth and normal, both of
-            // which assume a convex target. This query has never supported
-            // concave ones (`overlap_shape` decomposes them per-triangle;
-            // nothing here does), so rather than extend a convex-only
-            // inference to geometry the module cannot see properly, leave
-            // those on the unconditional "solid, blocked at t = 0" path.
-            const convex_target = collider.shape.is_convex !== false;
-            if (convex_target && !probe_contact_normal(probe_normal, ox, oy, oz, target_tr)) {
-                const known = recover_contact_normal(
-                    probe_normal, ox, oy, oz, dx, dy, dz, target_tr,
-                );
-                if (known) {
-                    // Both vectors are unit, so this is the sine of the angle
-                    // between the sweep and the contact plane. Zero means
-                    // exactly parallel — sliding along the face — and positive
-                    // means leaving it; neither blocks. The tolerance matters
-                    // because the parallel case sits right on the sign change,
-                    // and an MPR-recovered normal carries ~1e-6 of angular
-                    // noise: without it a sweep ALONG a face flips to
-                    // "head-on" on solver noise alone.
-                    const into = dx * probe_normal[0] + dy * probe_normal[1] + dz * probe_normal[2];
-                    if (into > -GRAZING_SINE_EPSILON) continue;
+            let t_aabb_enter = -Infinity;
+            let t_aabb_exit = Infinity;
+            let skip_candidate = false;
+            for (let ax = 0; ax < 3; ax++) {
+                const init_min = initial_aabb[ax];
+                const init_max = initial_aabb[ax + 3];
+                const body_min = target_world_aabb[ax];
+                const body_max = target_world_aabb[ax + 3];
+                const d_ax = ax === 0 ? dx : (ax === 1 ? dy : dz);
+                if (d_ax === 0) {
+                    // Static along this axis: AABBs must overlap in their
+                    // initial position or this candidate is unreachable.
+                    if (init_max < body_min || init_min > body_max) {
+                        skip_candidate = true;
+                        break;
+                    }
+                    continue;
                 }
+                // swept_min(t) = init_min + d·t, swept_max(t) = init_max + d·t.
+                // Slab-enter: swept_max(t) = body_min  →  t = (body_min − init_max) / d
+                // Slab-exit:  swept_min(t) = body_max  →  t = (body_max − init_min) / d
+                const t1 = (body_min - init_max) / d_ax;
+                const t2 = (body_max - init_min) / d_ax;
+                const lo = t1 < t2 ? t1 : t2;
+                const hi = t1 < t2 ? t2 : t1;
+                if (lo > t_aabb_enter) t_aabb_enter = lo;
+                if (hi < t_aabb_exit)  t_aabb_exit  = hi;
             }
-
-            best_t = 0;
-            best_body_id = body_id;
-            best_entity = entity;
-            break;
-        }
-
-        // ── Slab intersection: narrow the search interval analytically ─
-        //
-        // Compute the body's tight world AABB and intersect it with the
-        // swept shape's AABB sliding along the sweep direction. The
-        // result is the t-interval `[t_aabb_enter, t_aabb_exit]` during
-        // which the two AABBs overlap. Outside this interval the actual
-        // shapes can't overlap either (AABB is a superset of the
-        // shape), so we get to skip all of [0, t_aabb_enter) and
-        // (t_aabb_exit, best_t] without testing.
-        //
-        // This is the key to making `shapeCast` scale to long sweeps:
-        // a 1 km cast of a 1 m sphere against another 1 m sphere has an
-        // AABB-overlap window of ≈ 2 m (the sum of diameters along the
-        // sweep axis), reducing the coarse-step grid from a 30 m
-        // resolution (1000/32) to 6 cm (2/32).
-        collider.shape.compute_bounding_box(target_local_aabb);
-        aabb3_transform_oriented(
-            target_world_aabb, 0,
-            target_local_aabb[0], target_local_aabb[1], target_local_aabb[2],
-            target_local_aabb[3], target_local_aabb[4], target_local_aabb[5],
-            target_tr.translation_x, target_tr.translation_y, target_tr.translation_z,
-            target_tr.rotation_x, target_tr.rotation_y, target_tr.rotation_z, target_tr.rotation_w
-        );
-
-        let t_aabb_enter = -Infinity;
-        let t_aabb_exit = Infinity;
-        let skip_candidate = false;
-        for (let ax = 0; ax < 3; ax++) {
-            const init_min = initial_aabb[ax];
-            const init_max = initial_aabb[ax + 3];
-            const body_min = target_world_aabb[ax];
-            const body_max = target_world_aabb[ax + 3];
-            const d_ax = ax === 0 ? dx : (ax === 1 ? dy : dz);
-            if (d_ax === 0) {
-                // Static along this axis: AABBs must overlap in their
-                // initial position or this candidate is unreachable.
-                if (init_max < body_min || init_min > body_max) {
-                    skip_candidate = true;
+            if (skip_candidate) continue;
+            if (t_aabb_enter > t_aabb_exit) continue;
+
+            // Clamp to the relevant t-window: [0, best_t]. Anything beyond
+            // best_t can't tighten the answer.
+            const t_start = t_aabb_enter > 0     ? t_aabb_enter : 0;
+            const t_end   = t_aabb_exit  < best_t ? t_aabb_exit  : best_t;
+            if (t_start >= t_end) continue;
+
+            // Coarse-search within the narrowed interval to find any t for
+            // which the shapes overlap (their AABBs do by construction; the
+            // shapes themselves may not, e.g. two spheres passing alongside).
+            const step_dt = (t_end - t_start) / COARSE_STEPS;
+            let t_prev = t_start;
+            let t_hi = -1;
+            for (let s = 1; s <= COARSE_STEPS; s++) {
+                const t = t_start + s * step_dt;
+                swept_posed.px = ox + dx * t;
+                swept_posed.py = oy + dy * t;
+                swept_posed.pz = oz + dz * t;
+                if (gjk(simplex_buf, swept_posed, candidate_posed)) {
+                    t_hi = t;
                     break;
                 }
-                continue;
+                t_prev = t;
             }
-            // swept_min(t) = init_min + d·t, swept_max(t) = init_max + d·t.
-            // Slab-enter: swept_max(t) = body_min  →  t = (body_min − init_max) / d
-            // Slab-exit:  swept_min(t) = body_max  →  t = (body_max − init_min) / d
-            const t1 = (body_min - init_max) / d_ax;
-            const t2 = (body_max - init_min) / d_ax;
-            const lo = t1 < t2 ? t1 : t2;
-            const hi = t1 < t2 ? t2 : t1;
-            if (lo > t_aabb_enter) t_aabb_enter = lo;
-            if (hi < t_aabb_exit)  t_aabb_exit  = hi;
-        }
-        if (skip_candidate) continue;
-        if (t_aabb_enter > t_aabb_exit) continue;
-
-        // Clamp to the relevant t-window: [0, best_t]. Anything beyond
-        // best_t can't tighten the answer.
-        const t_start = t_aabb_enter > 0     ? t_aabb_enter : 0;
-        const t_end   = t_aabb_exit  < best_t ? t_aabb_exit  : best_t;
-        if (t_start >= t_end) continue;
-
-        // Coarse-search within the narrowed interval to find any t for
-        // which the shapes overlap (their AABBs do by construction; the
-        // shapes themselves may not, e.g. two spheres passing alongside).
-        const step_dt = (t_end - t_start) / COARSE_STEPS;
-        let t_prev = t_start;
-        let t_hi = -1;
-        for (let s = 1; s <= COARSE_STEPS; s++) {
-            const t = t_start + s * step_dt;
-            swept_posed.px = ox + dx * t;
-            swept_posed.py = oy + dy * t;
-            swept_posed.pz = oz + dz * t;
-            if (gjk(simplex_buf, swept_posed, candidate_posed)) {
-                t_hi = t;
-                break;
-            }
-            t_prev = t;
-        }
-        if (t_hi < 0) continue;
-
-        // Bisect [t_prev, t_hi]: invariant is `gjk(t_lo) === false` and
-        // `gjk(t_hi) === true`.
-        let t_lo = t_prev;
-        const stop_width = TOI_TOLERANCE * tMax;
-        for (let bi = 0; bi < MAX_BISECTION && (t_hi - t_lo) > stop_width; bi++) {
-            const t_mid = (t_lo + t_hi) * 0.5;
-            swept_posed.px = ox + dx * t_mid;
-            swept_posed.py = oy + dy * t_mid;
-            swept_posed.pz = oz + dz * t_mid;
-            if (gjk(simplex_buf, swept_posed, candidate_posed)) {
-                t_hi = t_mid;
-            } else {
-                t_lo = t_mid;
+            if (t_hi < 0) continue;
+
+            // Bisect [t_prev, t_hi]: invariant is `gjk(t_lo) === false` and
+            // `gjk(t_hi) === true`.
+            let t_lo = t_prev;
+            const stop_width = TOI_TOLERANCE * tMax;
+            for (let bi = 0; bi < MAX_BISECTION && (t_hi - t_lo) > stop_width; bi++) {
+                const t_mid = (t_lo + t_hi) * 0.5;
+                swept_posed.px = ox + dx * t_mid;
+                swept_posed.py = oy + dy * t_mid;
+                swept_posed.pz = oz + dz * t_mid;
+                if (gjk(simplex_buf, swept_posed, candidate_posed)) {
+                    t_hi = t_mid;
+                } else {
+                    t_lo = t_mid;
+                }
             }
-        }
 
-        // Use t_lo (the just-SEPARATING side of the bisection) rather
-        // than t_hi (just-overlapping). With the fixed GJK that no
-        // longer flags 5 mm-clear gaps as overlap, the bisection is
-        // tight; reporting t_lo gives kinematic callers a conservative
-        // TOI — the swept shape at the reported moment is provably NOT
-        // overlapping the target. The normal-probe below steps a few
-        // mm past best_t to get a valid simplex for MPR.
-        if (t_lo < best_t) {
-            best_t = t_lo;
-            best_body_id = body_id;
-            best_entity = entity;
+            // Use t_lo (the just-SEPARATING side of the bisection) rather
+            // than t_hi (just-overlapping). With the fixed GJK that no
+            // longer flags 5 mm-clear gaps as overlap, the bisection is
+            // tight; reporting t_lo gives kinematic callers a conservative
+            // TOI — the swept shape at the reported moment is provably NOT
+            // overlapping the target. The normal-probe below steps a few
+            // mm past best_t to get a valid simplex for MPR.
+            if (t_lo < best_t) {
+                best_t = t_lo;
+                best_body_id = body_id;
+                best_entity = entity;
+                best_collider = collider;
+                best_tr = target_tr;
+            }
         }
     }
 
@@ -610,11 +624,8 @@ export function shape_cast(system, ray, shape, rotation, result, filter = return
     const contact_x = ox + dx * best_t;
     const contact_y = oy + dy * best_t;
     const contact_z = oz + dz * best_t;
-    const best_body_idx = body_id_index(best_body_id);
-    const best_collider = system.__primary_collider(best_body_idx);
     let normal_x = -dx, normal_y = -dy, normal_z = -dz;
     if (best_collider !== null) {
-        const best_tr = system.__transforms[best_body_idx];
         candidate_posed.setup_components(
                 best_collider.shape,
                 best_tr.translation_x, best_tr.translation_y, best_tr.translation_z,

package/src/engine/physics/solver/solve_contacts.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"solve_contacts.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/solver/solve_contacts.js"],"names":[],"mappings":"AAkgBA;;;;;;;;;;;;;GAaG;AACH,0FAHW,MAAM,GACJ,MAAM,CAoNlB;AAED;;;;;;;;;;;;;;;GAeG;AACH,2FA0CC;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,uEAFW,aAAa,QAmGvB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,iGA2GC;AAED;;;;;;;;GAQG;AACH,uFAFW,MAAM,4BAwJhB;AAED;;;;;;;;;;;GAWG;AACH,yFAuDC;AAED;;;;;;;;;;;;;;GAcG;AACH,2FAFW,MAAM,QA2EhB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,oFAJW,MAAM,UACN,MAAM,cACN,MAAM,QAkDhB;AAhwCD;;;mBAGmB;AACnB,oCAAmC;AA3FnC;;;;;GAKG;AACH,0CAFU,MAAM,CAEuB;AAEvC;;;GAGG;AACH,0CAFU,MAAM,CAEsB"}
+{"version":3,"file":"solve_contacts.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/solver/solve_contacts.js"],"names":[],"mappings":"AA+gBA;;;;;;;;;;;;;GAaG;AACH,0FAHW,MAAM,GACJ,MAAM,CA8NlB;AAED;;;;;;;;;;;;;;;GAeG;AACH,2FA0CC;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,uEAFW,aAAa,QAmGvB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,iGA2GC;AAED;;;;;;;;GAQG;AACH,uFAFW,MAAM,4BAwJhB;AAED;;;;;;;;;;;GAWG;AACH,yFAuDC;AAED;;;;;;;;;;;;;;GAcG;AACH,2FAFW,MAAM,QA2EhB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,oFAJW,MAAM,UACN,MAAM,cACN,MAAM,QAkDhB;AA1wCD;;;mBAGmB;AACnB,oCAAmC;AA3FnC;;;;;GAKG;AACH,0CAFU,MAAM,CAEuB;AAEvC;;;GAGG;AACH,0CAFU,MAAM,CAEsB"}

package/src/engine/physics/solver/solve_contacts.js

@@ -19,9 +19,9 @@ import {
     SBS_QZ,
     SBS_STRIDE,
 } from "../body/SolverBodyState.js";
-import { CONTACT_STRIDE } from "../contact/ManifoldStore.js";
+import { CONTACT_FLAG_SENSOR, CONTACT_FLAGS_OFFSET, CONTACT_STRIDE } from "../contact/ManifoldStore.js";
 import { BodyKind } from "../ecs/BodyKind.js";
-import { is_sensor } from "../ecs/is_sensor.js";
+import { body_is_wholly_sensor } from "../ecs/is_sensor.js";
 import { angular_effective_mass_raw, world_inverse_inertia_apply_raw } from "../inertia/world_inverse_inertia.js";
 import { redetect_pair_geometry } from "../narrowphase/narrowphase_step.js";
 import { friction_cone_clamp } from "./friction_cone.js";
@@ -67,19 +67,32 @@ import { friction_cone_clamp } from "./friction_cone.js";
  */
 
 /**
- * A pair is "sensor-only" when either side {@link is_sensor} (the body OR its
- * primary collider carries the IsSensor flag). The manifold still exists (so
- * Begin/Stay/End events fire from the manifold-diff pass) but no impulse
- * is applied.
+ * Whether any collider on this body has a non-convex shape.
  *
- * @param {RigidBody} rbA
- * @param {Collider} colA
- * @param {RigidBody} rbB
- * @param {Collider} colB
+ * Read over the whole list for the same reason: a [box, trimesh] compound is
+ * concave, and asking only the first collider misclassified it into the frozen
+ * -feature analytic refresh, which this file's own notes say pumps energy in as
+ * the body rocks. Taking the re-detect path for a pair that did not need it
+ * costs time; missing it is wrong.
+ *
+ * @param {PhysicsSystem} system
+ * @param {number} body_idx
  * @returns {boolean}
  */
-function pair_is_sensor(rbA, colA, rbB, colB) {
-    return is_sensor(rbA, colA) || is_sensor(rbB, colB);
+function body_has_concave_collider(system, body_idx) {
+    const list = system.__body_collider_lists[body_idx];
+
+    if (list === undefined) {
+        return false;
+    }
+
+    for (let i = 0; i < list.length; i++) {
+        if (list[i].collider.shape.is_convex === false) {
+            return true;
+        }
+    }
+
+    return false;
 }
 
 /**
@@ -596,22 +609,22 @@ export function prepare_contacts(manifolds, system, dt_sub) {
         const trA = system.__transforms[idxA];
         const trB = system.__transforms[idxB];
 
-        const colA = system.__primary_collider(idxA);
-        const colB = system.__primary_collider(idxB);
-
-        if (colA === null || colB === null) {
+        // a body with no colliders at all has nothing here to solve
+        if (system.__primary_collider(idxA) === null || system.__primary_collider(idxB) === null) {
             continue;
         }
 
-        if (pair_is_sensor(rbA, colA, rbB, colB)) {
+        if (body_is_wholly_sensor(rbA, system.__body_collider_lists[idxA])
+            || body_is_wholly_sensor(rbB, system.__body_collider_lists[idxB])) {
             continue;
         }
 
-        // A pair is "concave" when either side's shape is non-convex. Those
+        // A pair is "concave" when either side has a non-convex shape. Those
         // contacts take the per-substep re-detection path (the contact
         // feature moves as the body rocks); convex pairs keep the cheap
         // analytic refresh. Recorded once per slot for redetect_concave_contacts.
-        const slot_concave = (colA.shape.is_convex === false) || (colB.shape.is_convex === false);
+        const slot_concave = body_has_concave_collider(system, idxA)
+            || body_has_concave_collider(system, idxB);
 
         if (slot_concave) {
             ensure_concave_slot_capacity(g_concave_slot_count + 1);
@@ -634,6 +647,16 @@ export function prepare_contacts(manifolds, system, dt_sub) {
         for (let k = 0; k < cc; k++) {
             const off = slot_off + k * CONTACT_STRIDE;
 
+            // This contact's own source-collider pair had a sensor on it: no
+            // impulse, while the contact still reaches the event diff. The
+            // decision is per contact because a compound body's colliders need
+            // not agree, and this is the only place that can tell them apart —
+            // the narrowphase stamped the flag where it knew which pair
+            // produced the contact.
+            if ((data[off + CONTACT_FLAGS_OFFSET] & CONTACT_FLAG_SENSOR) !== 0) {
+                continue;
+            }
+
             // Per-contact combined materials (stamped by the narrowphase from
             // this contact's specific source-collider pair).
             const friction_combined = data[off + 14];

package/src/engine/plugin/EnginePluginManager.d.ts

@@ -35,10 +35,20 @@ export class EnginePluginManager extends BaseProcess {
      * @private
      */
     private __getActivePluginContexts;
+    /**
+     * Every active context that names `PluginClass` among its dependencies.
+     *
+     * @param {Class<EnginePlugin>} PluginClass
+     * @returns {PluginReferenceContext[]}
+     * @private
+     */
+    private __get_dependent_contexts;
     /**
      *
      * @param {PluginReferenceContext} context
      * @param {ProcessState} state
+     * @param {Set<PluginReferenceContext>} [visited] contexts already on this walk, so a dependency
+     * cycle stops rather than recurring forever
      * @returns {Promise<void>}
      * @private
      */

package/src/engine/plugin/EnginePluginManager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"EnginePluginManager.d.ts","sourceRoot":"","sources":["../../../../src/engine/plugin/EnginePluginManager.js"],"names":[],"mappings":"AAOA;;;GAGG;AAEH;;;GAGG;AAEH;IAEI;;;OAGG;IACH,kBAAsB;IAEtB;;;OAGG;IACH,QAFU,MAAM,CAEF;IAEd;;;;OAIG;IACH,kBAAc;IAEd;;;;OAIG;IACH,mCAYC;IAED;;;;OAIG;IACH,kCAYC;IAGD;;;;;;OAMG;IACH,qCA0BC;IAED;;;;;OAKG;IACH,uCA2BC;IAED;;;;OAIG;IACH,+CAaC;IAED;;;OAGG;IACH,mBAFW,MAAM,QAkBhB;IAkBD,yBAIC;IAED,0BAIC;IAED;;;;OAIG;IACH,gDAuDC;IAED;;;;OAIG;IACH,2BAHW,KAAK,EAAE,GACL,QAAQ,uDAAW,CAAC,CAQhC;IAED;;;;OAIG;IACH,6CAaC;IAED;;;;OAIG;IACH,iBAHW,MAAM,sBAahB;CACJ;6BA/TY,OAAO,gCAAgC,EAAE,KAAK,CAAC,CAAC,CAAC;qBAIjD,OAAO,cAAc,EAAE,OAAO;;4BAbf,mCAAmC;6BAElC,mBAAmB"}
+{"version":3,"file":"EnginePluginManager.d.ts","sourceRoot":"","sources":["../../../../src/engine/plugin/EnginePluginManager.js"],"names":[],"mappings":"AAOA;;;GAGG;AAEH;;;GAGG;AAEH;IAEI;;;OAGG;IACH,kBAAsB;IAEtB;;;OAGG;IACH,QAFU,MAAM,CAEF;IAEd;;;;OAIG;IACH,kBAAc;IAEd;;;;OAIG;IACH,mCAYC;IAED;;;;OAIG;IACH,kCAYC;IAGD;;;;;;OAMG;IACH,iCAcC;IAED;;;;;;;;OAQG;IACH,qCAsDC;IAED;;;;;OAKG;IACH,uCA2BC;IAED;;;;OAIG;IACH,+CAaC;IAED;;;OAGG;IACH,mBAFW,MAAM,QAkBhB;IAkBD,yBAIC;IAED,0BAIC;IAED;;;;OAIG;IACH,gDAuDC;IAED;;;;OAIG;IACH,2BAHW,KAAK,EAAE,GACL,QAAQ,uDAAW,CAAC,CAQhC;IAED;;;;OAIG;IACH,6CAaC;IAED;;;;OAIG;IACH,iBAHW,MAAM,sBAahB;CACJ;6BApXY,OAAO,gCAAgC,EAAE,KAAK,CAAC,CAAC,CAAC;qBAIjD,OAAO,cAAc,EAAE,OAAO;;4BAbf,mCAAmC;6BAElC,mBAAmB"}

package/src/engine/plugin/EnginePluginManager.js

@@ -75,16 +75,47 @@ export class EnginePluginManager extends BaseProcess {
     }
 
 
+    /**
+     * Every active context that names `PluginClass` among its dependencies.
+     *
+     * @param {Class<EnginePlugin>} PluginClass
+     * @returns {PluginReferenceContext[]}
+     * @private
+     */
+    __get_dependent_contexts(PluginClass) {
+        const result = [];
+
+        for (const [, ctx] of this.__plugins) {
+            if (ctx.referenceCount <= 0) {
+                continue;
+            }
+
+            if (ctx.instance.dependencies.includes(PluginClass)) {
+                result.push(ctx);
+            }
+        }
+
+        return result;
+    }
+
     /**
      *
      * @param {PluginReferenceContext} context
      * @param {ProcessState} state
+     * @param {Set<PluginReferenceContext>} [visited] contexts already on this walk, so a dependency
+     * cycle stops rather than recurring forever
      * @returns {Promise<void>}
      * @private
      */
-    async __transition_plugin_to_state(context, state) {
+    async __transition_plugin_to_state(context, state, visited = new Set()) {
         const plugin = context.instance;
 
+        if (visited.has(context)) {
+            return;
+        }
+
+        visited.add(context);
+
         if (state === ProcessState.Initialized || state === ProcessState.Running) {
             const dependencies = plugin.dependencies;
 
@@ -105,6 +136,28 @@ export class EnginePluginManager extends BaseProcess {
                     }
                 }
             }
+        } else if (state === ProcessState.Finalized) {
+            /*
+             On the way down the graph is walked in reverse: every plugin that DEPENDS on this one
+             is finalized first, which is the mirror of the way up.
+
+             The walk above used to be the whole of it, and it is gated on the target state, so
+             `Finalized` resolved no order at all — `__transition_active_plugins_to` fired every
+             active context concurrently through `Promise.all` and teardown order was whatever the
+             map iteration and the microtask queue produced. A plugin whose `shutdown` releases
+             something a dependency owns worked or did not according to how many awaits each
+             plugin's teardown happened to contain, which is the shape of an intermittent "sometimes
+             throws on stop".
+
+             The recursion is transitive, so a chain of three goes down leaf-first, and
+             `context.transition` is a per-context serial queue, so reaching the same plugin from
+             two dependents transitions it once and waits on it twice.
+            */
+            const dependents = this.__get_dependent_contexts(context.getKlass());
+
+            for (let i = 0; i < dependents.length; i++) {
+                await this.__transition_plugin_to_state(dependents[i], state, visited);
+            }
         }
 
         await context.transition(state, this.engine);

package/src/engine/plugin/PluginReferenceContext.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"PluginReferenceContext.d.ts","sourceRoot":"","sources":["../../../../src/engine/plugin/PluginReferenceContext.js"],"names":[],"mappings":"AAgGA;IAyBI;;;;OAIG;IACH,qDAcC;IA3CD;;;;OAIG;IACH,qBAA0B;IAE1B;;;OAGG;IACH,uBAFU,KAAK,uBAAuB,CAAC,CAEJ;IAEnC;;MAEE;IAEF;;;;OAIG;IACH,qBAAiC;IAQ7B;;;;OAIG;IACH,gBAAoB;IAEpB;;;;OAIG;IACH,mBAA0B;IAG9B;;;;OAIG;IACH,eAFa,QAAQ,IAAI,CAAC,CAIzB;IAED;;;;;OAKG;IACH,yBAJW,YAAY,mBAEV,QAAQ,OAAO,CAAC,CA4C5B;IAED,yBAeC;IAGD;;;;OAIG;IACH,oCASC;IAED,qBAEC;IAED;;;OAGG;IACH,+BASC;IAED;;;OAGG;IACH,6BAEC;IAED;;;OAGG;IACH,6BAEC;CACJ;iBA7QgB,oCAAoC;0BAC3B,8BAA8B;mBACrC,oCAAoC;6BAC1B,oCAAoC"}
+{"version":3,"file":"PluginReferenceContext.d.ts","sourceRoot":"","sources":["../../../../src/engine/plugin/PluginReferenceContext.js"],"names":[],"mappings":"AAoGA;IAyBI;;;;OAIG;IACH,qDAcC;IA3CD;;;;OAIG;IACH,qBAA0B;IAE1B;;;OAGG;IACH,uBAFU,KAAK,uBAAuB,CAAC,CAEJ;IAEnC;;MAEE;IAEF;;;;OAIG;IACH,qBAAiC;IAQ7B;;;;OAIG;IACH,gBAAoB;IAEpB;;;;OAIG;IACH,mBAA0B;IAG9B;;;;OAIG;IACH,eAFa,QAAQ,IAAI,CAAC,CAIzB;IAED;;;;;OAKG;IACH,yBAJW,YAAY,mBAEV,QAAQ,OAAO,CAAC,CA4C5B;IAED,yBAeC;IAGD;;;;OAIG;IACH,oCASC;IAED,qBAEC;IAED;;;OAGG;IACH,+BASC;IAED;;;OAGG;IACH,6BAEC;IAED;;;OAGG;IACH,6BAEC;CACJ;iBAjRgB,oCAAoC;0BAC3B,8BAA8B;mBACrC,oCAAoC;6BAC1B,oCAAoC"}

package/src/engine/plugin/PluginReferenceContext.js

@@ -27,9 +27,13 @@ function navigate_to_initialized(plugin, engine) {
 
     if (s === ProcessState.New || s === ProcessState.Finalized) {
 
-        plugin.initialize(engine);
-
-        return Promise.resolve();
+        // The return value is carried, not discarded. `navigate_to_running` chains `startup()`
+        // onto this, so throwing away an async `initialize`'s promise had `startup` called one
+        // microtask later - before `initialize` had assigned the fields `startup` reads - and a
+        // rejection became an unhandled rejection rather than failing the transition. The base
+        // EnginePlugin.initialize is synchronous, but nothing enforces that and
+        // AchievementManager declares its own `async`.
+        return Promise.resolve(plugin.initialize(engine));
 
     } else if (s === ProcessState.Running) {