@woosh/meep-engine 3.38.0 → 3.40.0

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

@@ -1,39 +1,65 @@
-import { aabb3_transform_oriented } from "../../../core/geom/3d/aabb/aabb3_transform_oriented.js";
+import { aabb3_transform_oriented_array } from "../../../core/geom/3d/aabb/aabb3_transform_oriented.js";
 import { Triangle3D } from "../../../core/geom/3d/shape/Triangle3D.js";
 import { body_id_index } from "../body/BodyStorage.js";
 import { ColliderFlags } from "../ecs/ColliderFlags.js";
 import { combine_friction, combine_restitution } from "../contact/combine_material.js";
-import { CONTACT_FLAG_SENSOR, CONTACT_STRIDE, MAX_CONTACTS_PER_MANIFOLD } from "../contact/ManifoldStore.js";
+import {
+    CONTACT_FLAG_SENSOR,
+    CONTACT_FLAGS_OFFSET,
+    CONTACT_STRIDE,
+    MAX_CONTACTS_PER_MANIFOLD
+} from "../contact/ManifoldStore.js";
 import { GJK_SEPARATED, gjk_epa_penetration } from "../../../core/geom/3d/gjk/gjk_epa_penetration.js";
-import { reduce_manifold_contacts } from "./reduce_manifold_contacts.js";
+import { reduce_manifold_contacts_by_plane } from "./reduce_manifold_contacts.js";
 import { mpr } from "../../../core/geom/3d/gjk/mpr.js";
-import { box_box_manifold, BOX_BOX_OUT_LENGTH } from "./box_box_manifold.js";
-import { convex_hull_clip, CONVEX_CONVEX_OUT_LENGTH } from "./convex_convex_manifold.js";
+import { box_box_manifold_array, BOX_BOX_OUT_LENGTH } from "./box_box_manifold.js";
+import { convex_hull_clip_array, CONVEX_CONVEX_OUT_LENGTH } from "./convex_convex_manifold.js";
 import { get_mesh_convex_hull } from "./mesh_convex_hull.js";
 import { mesh_mesh_tet_contacts } from "./mesh_mesh_tet_manifold.js";
-import { box_triangle_contact, BOX_TRIANGLE_OUT_LENGTH } from "./box_triangle_contact.js";
+import {
+    BOX_TRIANGLE_AXIS_BOX_FACE,
+    BOX_TRIANGLE_AXIS_OFFSET,
+    BOX_TRIANGLE_AXIS_TRIANGLE_FACE,
+    box_triangle_contact_array,
+    BOX_TRIANGLE_OUT_LENGTH
+} from "./box_triangle_contact.js";
 import {
     CAPSULE_BOX_CONTACT_STRIDE,
     CAPSULE_BOX_MAX_CONTACTS,
-    capsule_box_multi_contacts,
-    capsule_capsule_contact,
+    capsule_box_multi_contacts_array,
     CAPSULE_CAPSULE_CONTACT_STRIDE,
-    capsule_capsule_multi_contacts,
-    capsule_sphere_contact,
+    capsule_capsule_multi_contacts_array,
+    capsule_sphere_contact_array,
 } from "./capsule_contacts.js";
 import {
-    capsule_triangle_contact,
+    capsule_triangle_contact_array,
     CAPSULE_TRIANGLE_CONTACT_STRIDE,
     CAPSULE_TRIANGLE_MAX_CONTACTS,
 } from "./capsule_triangle_contact.js";
-import { aabb3_transform_oriented_inverse } from "../../../core/geom/3d/aabb/aabb3_transform_oriented_inverse.js";
-import { decompose_to_triangles } from "./decomposition/decompose_to_triangles.js";
+import { aabb3_transform_oriented_inverse_array } from "../../../core/geom/3d/aabb/aabb3_transform_oriented_inverse.js";
+import { decompose_to_triangles_array } from "./decomposition/decompose_to_triangles.js";
 import { TRIANGLE_FLOAT_STRIDE } from "./decomposition/triangle_buffer_layout.js";
+import { triangle_edge_flags, triangle_vertex_flat } from "./decomposition/triangle_edge_flags.js";
+import { FLAT_EDGE_COS, TriangleEdgeFlags } from "../../../core/geom/3d/triangle/TriangleEdgeFlags.js";
 import { PosedShape3D } from "../../../core/geom/3d/shape/PosedShape3D.js";
-import { sphere_box_contact } from "./sphere_box_contact.js";
-import { sphere_sphere_contact } from "./sphere_sphere_contact.js";
-import { sphere_triangle_contact } from "./sphere_triangle_contact.js";
-import { Transform64 } from "../../ecs/transform/Transform64.js";
+import { hull_sphere_contact_array } from "./hull_sphere_contact.js";
+import {
+    feature_manifold,
+    FEATURE_MANIFOLD_OUT_LENGTH,
+    FEATURE_POLYGON,
+    support_feature,
+    SupportFeature,
+    triangle_feature
+} from "./support_feature_manifold.js";
+import { sphere_box_contact_array } from "./sphere_box_contact.js";
+import { sphere_sphere_contact_array } from "./sphere_sphere_contact.js";
+import { sphere_triangle_contact_array } from "./sphere_triangle_contact.js";
+import {
+    Transform64,
+    TRANSFORM64_ROTATION_OFFSET,
+    TRANSFORM64_TRANSLATION_OFFSET
+} from "../../ecs/transform/Transform64.js";
+import { rigid_subject_pose } from "./rigid_subject_pose.js";
 
 const posed_a = new PosedShape3D();
 const posed_b = new PosedShape3D();
@@ -52,11 +78,26 @@ const box_triangle_result = new Float64Array(BOX_TRIANGLE_OUT_LENGTH);
 const capsule_triangle_result = new Float64Array(CAPSULE_TRIANGLE_MAX_CONTACTS * CAPSULE_TRIANGLE_CONTACT_STRIDE);
 const box_manifold_result = new Float64Array(BOX_BOX_OUT_LENGTH);
 const convex_manifold_result = new Float64Array(CONVEX_CONVEX_OUT_LENGTH);
+
+/**
+ * The two poses {@link convex_hull_clip} takes as arrays, copied out of the transforms: reading a
+ * Transform64's `translation` or `rotation` builds a fresh view on every read.
+ */
+const hull_position_a = new Float64Array(3);
+const hull_rotation_a = new Float64Array(4);
+const hull_position_b = new Float64Array(3);
+const hull_rotation_b = new Float64Array(4);
+
 const capsule_box_multi_result = new Float64Array(CAPSULE_BOX_MAX_CONTACTS * CAPSULE_BOX_CONTACT_STRIDE);
 
+/** Supporting features of the two sides, and their manifold, for the GJK + EPA paths. */
+const feature_a = new SupportFeature();
+const feature_b = new SupportFeature();
+const feature_manifold_result = new Float64Array(FEATURE_MANIFOLD_OUT_LENGTH);
+
 /**
  * Candidate-contact stride: wax, way, waz, wbx, wby, wbz, nx, ny, nz, depth,
- * feature_id, friction, restitution.
+ * feature_id, friction, restitution, flags.
  *
  * The `feature_id` (offset 10) is a stable cross-frame identifier of the
  * geometric feature pair that produced this contact — used by the
@@ -71,6 +112,9 @@ const capsule_box_multi_result = new Float64Array(CAPSULE_BOX_MAX_CONTACTS * CAP
  * on each side) and carried into the manifold so a compound body's per-collider
  * materials are honoured per-contact.
  *
+ * `flags` (offset 13) are that same collider pair's per-contact bits — see
+ * {@link CONTACT_FLAG_SENSOR}.
+ *
  * @type {number}
  */
 const CANDIDATE_STRIDE = 14;
@@ -191,6 +235,9 @@ const CANDIDATE_CAPACITY_INITIAL = 64;
  */
 let redetect_claimed = new Uint8Array(CANDIDATE_CAPACITY_INITIAL);
 
+/** Data offsets of the contacts a re-detection found no candidate for (see {@link redetect_pair_geometry}). */
+const redetect_stale = new Int32Array(64);
+
 /**
  * Per body-pair scratch buffer for candidate contacts produced by the
  * cross-product of A's colliders × B's colliders.
@@ -230,36 +277,1110 @@ function grow_candidates() {
     redetect_claimed = new Uint8Array(capacity);
 }
 
+/*
+ * ## Concave-dispatch contact dedup index
+ *
+ * Adjacent triangles report the same contact where they share an edge or a
+ * vertex, so each per-triangle path drops a new contact when an earlier one of
+ * the same dispatch matches it: the sphere path when a normal lies within
+ * 0.001 (squared) of the new one, the box / capsule / feature paths when a
+ * normal does AND the stored A-side witness lies within 1e-6 (squared) of the
+ * new one. That was a scan over every earlier contact of the dispatch, per
+ * contact: quadratic in contacts, and with the triangle cap gone a 4 m crate
+ * on a floor meshed at 10 cm paid ~100 ms a step for it.
+ *
+ * The test is unchanged; what changes is which earlier contacts it is run
+ * against. Each kept contact is filed under a grid cell of its key — the
+ * witness for the point paths, the normal for the sphere path — and a new
+ * contact is tested, with the very same arithmetic, against the contacts filed
+ * in the cells its tolerance can reach. Whether a match exists does not depend
+ * on the order the earlier contacts are tested in, so the contacts kept, and
+ * their order, are exactly what the scan kept.
+ *
+ * Reach: a squared distance that rounds below 1e-6 has every component under
+ * 1e-3 (1 + 3 ulp); cells of 1/256 put that at 0.256 of a cell, so only the
+ * neighbour across a face nearer than {@link DEDUP_REACH} can hold a match.
+ * Normals: under sqrt(0.001) = 0.0316 per component, cells of 1/8, 0.253 of a
+ * cell. The scales are powers of two, so `key * scale` and its fraction are
+ * exact. A component that scales to a non-finite value files and looks up in
+ * cell 0 on that axis alike, so equal keys still meet (a non-finite key never
+ * passes the test anyway).
+ *
+ * Buckets are reset by stamp, entries by count, so a dispatch costs nothing
+ * per bucket; both grow with the high-water mark and are kept.
+ */
+
+/** Cell size 1/256 m for witness points (tolerance 1 mm). */
+const DEDUP_POINT_SCALE = 256;
+
+/** Cell size 1/8 for unit normals (tolerance 0.0316). */
+const DEDUP_NORMAL_SCALE = 8;
+
+/** Either tolerance in cell units (0.256, 0.253), rounded up. */
+const DEDUP_REACH = 0.26;
+
+/** @type {Int32Array} first entry of each bucket, valid when its stamp is current */
+let dedup_bucket_head = new Int32Array(1024);
+/** @type {Int32Array} */
+let dedup_bucket_stamp = new Int32Array(1024);
+/** @type {Int32Array} candidate index of each entry */
+let dedup_entry_candidate = new Int32Array(1024);
+/** @type {Int32Array} next entry in the same bucket, -1 ends */
+let dedup_entry_next = new Int32Array(1024);
+let dedup_entry_count = 0;
+let dedup_stamp = 0;
+
+/**
+ * Key of the dispatch in progress: the normal (sphere path) or the A-side
+ * witness (every other path). One dispatch takes one path.
+ * @type {boolean}
+ */
+let dedup_by_normal = false;
+
+/**
+ * Start an empty index for a concave dispatch.
+ * @param {boolean} by_normal
+ */
+function dedup_begin(by_normal) {
+    dedup_by_normal = by_normal;
+    dedup_entry_count = 0;
+    dedup_stamp++;
+
+    if (dedup_stamp === 0x7FFFFFFF) {
+        dedup_bucket_stamp.fill(0);
+        dedup_stamp = 1;
+    }
+}
+
+/**
+ * @param {number} cx integer-valued cell coordinate (any double; non-finite folds to 0)
+ * @param {number} cy
+ * @param {number} cz
+ * @returns {number} bucket index
+ */
+function dedup_bucket(cx, cy, cz) {
+    return (Math.imul(cx | 0, 73856093) ^ Math.imul(cy | 0, 19349663) ^ Math.imul(cz | 0, 83492791))
+        & (dedup_bucket_head.length - 1);
+}
+
+/**
+ * File entry `e` (already holding its candidate index) under its key's cell.
+ * @param {number} e
+ */
+function dedup_file(e) {
+    const scale = dedup_by_normal ? DEDUP_NORMAL_SCALE : DEDUP_POINT_SCALE;
+    const o = dedup_entry_candidate[e] * CANDIDATE_STRIDE + (dedup_by_normal ? 6 : 0);
+
+    const b = dedup_bucket(
+        Math.floor(candidates[o] * scale),
+        Math.floor(candidates[o + 1] * scale),
+        Math.floor(candidates[o + 2] * scale)
+    );
+
+    if (dedup_bucket_stamp[b] !== dedup_stamp) {
+        dedup_bucket_stamp[b] = dedup_stamp;
+        dedup_bucket_head[b] = -1;
+    }
+
+    dedup_entry_next[e] = dedup_bucket_head[b];
+    dedup_bucket_head[b] = e;
+}
+
+/**
+ * Index candidate `index`, just appended by the dispatch in progress.
+ * @param {number} index
+ */
+function dedup_insert(index) {
+    const e = dedup_entry_count;
+
+    if (e === dedup_entry_candidate.length) {
+        const candidate = new Int32Array(e * 2);
+        candidate.set(dedup_entry_candidate);
+        dedup_entry_candidate = candidate;
+        dedup_entry_next = new Int32Array(e * 2);
+
+        // re-chain below, with the buckets
+        dedup_entry_count = e;
+        dedup_rebuild(dedup_bucket_head.length);
+    }
+
+    dedup_entry_candidate[e] = index;
+    dedup_entry_count = e + 1;
+
+    if (dedup_entry_count * 2 > dedup_bucket_head.length) {
+        dedup_rebuild(dedup_bucket_head.length * 2);
+    } else {
+        dedup_file(e);
+    }
+}
+
+/**
+ * Re-file every entry into `bucket_count` buckets.
+ * @param {number} bucket_count power of two
+ */
+function dedup_rebuild(bucket_count) {
+    if (bucket_count !== dedup_bucket_head.length) {
+        dedup_bucket_head = new Int32Array(bucket_count);
+        dedup_bucket_stamp = new Int32Array(bucket_count);
+    }
+
+    // a fresh stamp empties every bucket
+    dedup_stamp++;
+
+    if (dedup_stamp === 0x7FFFFFFF) {
+        dedup_bucket_stamp.fill(0);
+        dedup_stamp = 1;
+    }
+
+    for (let e = 0; e < dedup_entry_count; e++) {
+        dedup_file(e);
+    }
+}
+
 /**
- * Maximum triangles a concave-side enumerator can produce per pair.
- * The query AABB is bounded by the broadphase's fattened envelope of
- * the convex-side body, so a single concave-vs-convex pair typically
- * yields tens of triangles, not thousands. 1024 is the safety cap.
+ * Whether an earlier contact of the dispatch in progress matches a new one —
+ * the per-path test, run against the contacts filed where it can pass.
+ *
+ * The new contact is read from a record laid out as {@link append_contact}
+ * takes its numbers: A-side witness at `offset` (ignored when keyed by
+ * normal), stored normal at `offset + 6`. See {@link staged_contact}.
+ *
+ * @param {Float64Array} contact
+ * @param {number} offset
+ * @returns {boolean}
+ */
+function dedup_contains(contact, offset) {
+    const px = contact[offset], py = contact[offset + 1], pz = contact[offset + 2];
+    const nx = contact[offset + 6], ny = contact[offset + 7], nz = contact[offset + 8];
+
+    const by_normal = dedup_by_normal;
+    const scale = by_normal ? DEDUP_NORMAL_SCALE : DEDUP_POINT_SCALE;
+
+    const sx = (by_normal ? nx : px) * scale;
+    const sy = (by_normal ? ny : py) * scale;
+    const sz = (by_normal ? nz : pz) * scale;
+
+    const cx = Math.floor(sx), cy = Math.floor(sy), cz = Math.floor(sz);
+    const fx = sx - cx, fy = sy - cy, fz = sz - cz;
+
+    // cells per axis: the key's own, plus a neighbour whose face is in reach
+    const x0 = fx < DEDUP_REACH ? cx - 1 : cx;
+    const y0 = fy < DEDUP_REACH ? cy - 1 : cy;
+    const z0 = fz < DEDUP_REACH ? cz - 1 : cz;
+    const nx_cells = 1 + (fx < DEDUP_REACH ? 1 : 0) + (fx > 1 - DEDUP_REACH ? 1 : 0);
+    const ny_cells = 1 + (fy < DEDUP_REACH ? 1 : 0) + (fy > 1 - DEDUP_REACH ? 1 : 0);
+    const nz_cells = 1 + (fz < DEDUP_REACH ? 1 : 0) + (fz > 1 - DEDUP_REACH ? 1 : 0);
+
+    for (let ix = 0; ix < nx_cells; ix++) {
+        for (let iy = 0; iy < ny_cells; iy++) {
+            for (let iz = 0; iz < nz_cells; iz++) {
+                const b = dedup_bucket(x0 + ix, y0 + iy, z0 + iz);
+
+                if (dedup_bucket_stamp[b] !== dedup_stamp) continue;
+
+                for (let e = dedup_bucket_head[b]; e !== -1; e = dedup_entry_next[e]) {
+                    const qo = dedup_entry_candidate[e] * CANDIDATE_STRIDE;
+
+                    const dnx = candidates[qo + 6] - nx;
+                    const dny = candidates[qo + 7] - ny;
+                    const dnz = candidates[qo + 8] - nz;
+
+                    if (dnx * dnx + dny * dny + dnz * dnz < 0.001) {
+                        if (by_normal) return true;
+
+                        const dpx = candidates[qo] - px;
+                        const dpy = candidates[qo + 1] - py;
+                        const dpz = candidates[qo + 2] - pz;
+
+                        if (dpx * dpx + dpy * dpy + dpz * dpz < 1e-6) return true;
+                    }
+                }
+            }
+        }
+    }
+
+    return false;
+}
+
+/*
+ * ## Internal edges ("ghost" contacts)
  *
- * For a heightmap the per-cell triangle count scales O(N²) with the
- * shape's {@link HeightMapShape3D#tessellation} (a sub-cell quad is 2
- * triangles, and there are N×N sub-cells per sampler cell). The bounded
- * query AABB keeps the cell count small, so a typical pair stays well
- * inside 1024 at moderate tessellation; the silent-drop backstop below
- * covers any overflow at extreme values.
+ * A flat floor cut into triangles is collided one triangle at a time, and each triangle on its own has
+ * edges the floor does not. A body sliding from one triangle onto the next first touches the next
+ * one's near edge — a sliver of overlap the per-triangle routine resolves along whatever axis is
+ * shortest for that triangle alone: the box's leading face (pushing it back), or an edge-edge axis
+ * tilted off the floor's normal (kicking it up and spinning it). A sphere crossing the same edge gets
+ * a second contact on it, beside the face contact of the triangle it is over, tilted and as deep. A
+ * frictionless box crossing a flat triangulated floor at 6 m/s hopped 0.1 m and lost a third of its
+ * speed; a sphere hopped by centimetres; both crossed a box floor without either.
  *
- * Enumerators return the TRUE overlap count and have no bounds check of
- * their own: writes past the scratch buffer are dropped (typed-array OOB
- * semantics), so on overflow the consume loop MUST clamp the returned
- * count to this cap or it reads `undefined` past the end and poisons the
- * manifold with NaN. The worst case after clamping is a missed contact
- * on a far edge of the filtered region, which the next-step
- * rebroadphase corrects.
+ * Box3D's answer (mesh_contact.c, `b3ComputeMeshManifolds`, MIT, Erin Catto), ported here: each
+ * triangle's contacts are FACE contacts — on the triangle's face, or a face of the convex body lying
+ * within 60° of the triangle's plane — or TENTATIVE: on an edge or a vertex of the triangle. Face
+ * contacts are kept as they are. (Box3D counts a deep contact on a body face as a face contact at any
+ * angle, so that it is never dropped; here no contact is dropped for lying on a flat feature, and the
+ * rule only kept a body face's normal where the plane's belonged: a box landing tilted on a small
+ * triangle, its back face 12 mm into it, was pushed sideways by its own face and stopped dead on a flat
+ * floor.) Tentative ones:
  *
+ *  - a sphere's are kept, closest first, when the feature they touch (an edge or a vertex) is not yet
+ *    claimed — by a face contact's triangle, or by a nearer tentative one's (each claims its edges and
+ *    vertices whether or not it was kept) — and dropped otherwise, as Box3D does. A sphere's face
+ *    contact is the nearest point of the surface, so a contact on an edge or vertex of that face's
+ *    triangle can only repeat it, further off and tilted. Claims go by coordinates, though, and a
+ *    neighbour can have the edge under other ones — its copy of a vertex a hair away, or the edge
+ *    split at a T-junction — so a kept contact on a FLAT edge or corner is taken as the plane's,
+ *    like everything else's below;
+ *  - anything else's are judged by where on its triangle the contact lies ({@link
+ *    triangle_witness_feature}). Inside the triangle, or on an edge or a corner that is {@link
+ *    TriangleEdgeFlags FLAT} — no feature of the surface, an artefact of its triangulation — the
+ *    contact is taken as the plane's: its normal becomes the triangle's, its depth the body's depth
+ *    below that plane (dropped if not below it). On a real edge or corner — convex, concave, the rim,
+ *    a vertex any real edge meets — it is kept as it is: the surface has that feature. A round body
+ *    (sphere, capsule) touches a plane under its core. Where that point lies off the triangle and the
+ *    contact meets the feature from more than a flat edge's bend off the plane's normal, the body is
+ *    not on this face — a capsule riding over a 1 cm step touched the riser's internal diagonal from
+ *    above, and taken as the riser's plane that contact pushed it back by its whole 8 cm intrusion into
+ *    that plane, turning it round — and the contact goes. Otherwise it is the plane's: on the top of a
+ *    convex crease flatter than that the point lies off both triangles, and neither holds the body.
+ *
+ *    Box3D judges the triangle instead: a tentative contact goes when every edge of its triangle is
+ *    flat, or one of them is flat and shared with a triangle that made a face contact — wherever on
+ *    the triangle the contact lies. The triangle beside a ridge whose one corner is on the crest has
+ *    every edge flat, so its contact at that corner, on the crest, went too: a box resting on two
+ *    knife-edged rails got the flanks' normals there, 72° off vertical, and slid off sideways, and a
+ *    lying cylinder driven into a 0.3 m riser spun up to 3.2 rad/s. And Box3D drops these contacts,
+ *    where this takes them as the plane's: its triangle-hull SAT prefers a face axis, falling back to
+ *    an edge pair only when face clipping fails, so its tentative contacts are the odd few; this
+ *    box-triangle SAT takes whichever axis overlaps least, so a box corner pressed onto a vertex of a
+ *    finely cut convex surface gets all its deep contacts on edge axes — and dropping them sank a cube
+ *    balanced on a corner of a dome 166 mm where it used to sink 2 mm.
+ *
+ * Features are recognised by their coordinates in the shape's frame, which a vertex shared by two
+ * triangles has bit for bit in both (see triangle_buffer_layout.js). Edge and corner classes are
+ * looked up ({@link triangle_edge_flags}, {@link triangle_vertex_flat}) for the triangles of tentative
+ * contacts only: a mesh keeps them, a heightmap samples them. Classifying every enumerated heightmap
+ * triangle instead — a ring of extra samples around each query — cost a heightmap terrain scene a
+ * fifth of its step.
+ */
+
+/**
+ * A contact whose normal is within this cosine of its triangle's face normal is on the face. The
+ * closest-point paths (sphere, capsule) leave the normal exactly the face's when the nearest point is
+ * inside the triangle, so this only has to absorb rounding.
+ * @type {number}
+ */
+const FACE_CONTACT_COS = 1 - 1e-6;
+
+/**
+ * A face of the convex body clipping a triangle makes a face contact when within this cosine of the
+ * triangle's normal: Box3D's 0.5 (60°) for a hull face.
  * @type {number}
  */
-const MAX_TRIANGLES_PER_PAIR = 1024;
+const HULL_FACE_COS = 0.5;
+
+
+/**
+ * Feature of a triangle a tentative contact touches: edges A→B, B→C, C→A, then vertices A, B, C, then
+ * the face; NONE for a triangle with no area to place a point in.
+ */
+const FEATURE_EDGE_AB = 0;
+const FEATURE_VERTEX_A = 3;
+const FEATURE_FACE = 6;
+const FEATURE_NONE = 7;
+
+/**
+ * A point is on an edge of a triangle when its barycentric weight of the vertex across from that edge
+ * is at most this: a micrometre from the edge of a triangle a metre across. The contact routines
+ * place their points on an edge by interpolating along it, which is exact to rounding, many orders
+ * below this; a point really inside the triangle, as near the edge as this, is on the plane either way.
+ * @type {number}
+ */
+const ON_EDGE_WEIGHT = 1e-6;
+
+/**
+ * Tentative contacts of the concave dispatch in progress. Stride: the eleven values
+ * {@link append_contact} takes (A witness, B witness, stored normal, depth, fid), the index of the
+ * triangle in {@link triangle_buffer}, its feature on that triangle, and the sort key (squared distance
+ * to the sphere's centre). Grown by doubling, high-water mark kept.
+ */
+const TENTATIVE_STRIDE = 14;
+let tentatives = new Float64Array(64 * TENTATIVE_STRIDE);
+let tentative_count = 0;
+
+/** Processing order of the tentatives (closest first, for the sphere rule). */
+let tentative_order = new Int32Array(64);
+
+/**
+ * Indices in {@link triangle_buffer} of the triangles with a face contact in the sphere dispatch in
+ * progress (the sphere rule's claims).
+ */
+let face_triangles = new Int32Array(64);
+let face_triangle_count = 0;
+
+/**
+ * A contact the concave dispatch is about to keep, stash or test, in the order {@link append_contact}
+ * takes its numbers — A witness (0..2), B witness (3..5), stored normal (6..8), depth (9), fid (10) —
+ * then a tentative contact's sort key (11). The per-contact helpers below take it as an array: none of
+ * them is inlined into dispatch_pair, and a call that is not inlined boxes each number passed to it.
+ */
+const staged_contact = new Float64Array(12);
 
 /**
- * Per-pair scratch for the concave-side triangle decomposition.
+ * Stash a tentative contact, already oriented as {@link append_contact} wants it: the eleven values
+ * and the sort key of `contact` (see {@link staged_contact}).
+ *
+ * @param {Float64Array} contact
+ * @param {number} triangle
+ * @param {number} feature
+ */
+function tentative_add(contact, triangle, feature) {
+    if ((tentative_count + 1) * TENTATIVE_STRIDE > tentatives.length) {
+        const grown = new Float64Array(tentatives.length * 2);
+        grown.set(tentatives);
+        tentatives = grown;
+        tentative_order = new Int32Array(grown.length / TENTATIVE_STRIDE);
+    }
+
+    const o = tentative_count * TENTATIVE_STRIDE;
+
+    tentatives[o] = contact[0]; tentatives[o + 1] = contact[1]; tentatives[o + 2] = contact[2];
+    tentatives[o + 3] = contact[3]; tentatives[o + 4] = contact[4]; tentatives[o + 5] = contact[5];
+    tentatives[o + 6] = contact[6]; tentatives[o + 7] = contact[7]; tentatives[o + 8] = contact[8];
+    tentatives[o + 9] = contact[9];
+    tentatives[o + 10] = contact[10];
+    tentatives[o + 11] = triangle;
+    tentatives[o + 12] = feature;
+    tentatives[o + 13] = contact[11];
+
+    tentative_count++;
+}
+
+/**
+ * Note that triangle `i` (index in {@link triangle_buffer}) made a face contact. Its contacts arrive
+ * together, so a repeat is the last entry.
+ * @param {number} i
+ */
+function face_triangle_add(i) {
+    if (face_triangle_count > 0 && face_triangles[face_triangle_count - 1] === i) {
+        return;
+    }
+
+    if (face_triangle_count === face_triangles.length) {
+        const grown = new Int32Array(face_triangle_count * 2);
+        grown.set(face_triangles);
+        face_triangles = grown;
+    }
+
+    face_triangles[face_triangle_count++] = i;
+}
+
+/**
+ * Which feature of a triangle faces a direction: the vertices tied at its extreme along it — an edge
+ * for two, a vertex for one, the face for three. For a closest-point contact, the direction from the
+ * triangle to the body, this is the region the nearest point lies in.
+ *
+ * The triangle (world) and the direction are read from arrays, as the concave dispatch has them.
+ *
+ * @param {Float64Array} triangle vertices A, B, C
+ * @param {Float64Array} direction
+ * @param {number} direction_offset
+ * @returns {number} {@link FEATURE_EDGE_AB} + k for edge k, {@link FEATURE_VERTEX_A} + k for vertex k,
+ *   {@link FEATURE_FACE}
+ */
+function triangle_facing_feature(triangle, direction, direction_offset) {
+    const ax = triangle[0], ay = triangle[1], az = triangle[2];
+    const bx = triangle[3], by = triangle[4], bz = triangle[5];
+    const cx = triangle[6], cy = triangle[7], cz = triangle[8];
+    const dx = direction[direction_offset], dy = direction[direction_offset + 1], dz = direction[direction_offset + 2];
+
+    const da = ax * dx + ay * dy + az * dz;
+    const db = bx * dx + by * dy + bz * dz;
+    const dc = cx * dx + cy * dy + cz * dz;
+
+    const hi = Math.max(da, db, dc);
+    const floor = hi - (hi - Math.min(da, db, dc)) * 1e-6;
+
+    const ta = da >= floor, tb = db >= floor, tc = dc >= floor;
+
+    if (ta && tb && tc) return FEATURE_FACE;
+    if (ta && tb) return FEATURE_EDGE_AB;
+    if (tb && tc) return FEATURE_EDGE_AB + 1;
+    if (tc && ta) return FEATURE_EDGE_AB + 2;
+    if (ta) return FEATURE_VERTEX_A;
+    if (tb) return FEATURE_VERTEX_A + 1;
+    return FEATURE_VERTEX_A + 2;
+}
+
+/**
+ * Which feature of a triangle a point on it lies on: an edge when within {@link ON_EDGE_WEIGHT} of it
+ * (or past it), the vertex two such edges meet, else the face. The point is taken where it projects
+ * onto the triangle's plane.
+ *
+ * The triangle (world) and the point are read from arrays, as the concave dispatch has them.
+ *
+ * @param {Float64Array} triangle vertices A, B, C
+ * @param {Float64Array} point
+ * @param {number} point_offset
+ * @returns {number} {@link FEATURE_EDGE_AB} + k for edge k, {@link FEATURE_VERTEX_A} + k for vertex k,
+ *   {@link FEATURE_FACE}, or {@link FEATURE_NONE} for a triangle without area
+ */
+function triangle_witness_feature(triangle, point, point_offset) {
+    const ax = triangle[0], ay = triangle[1], az = triangle[2];
+    const bx = triangle[3], by = triangle[4], bz = triangle[5];
+    const cx = triangle[6], cy = triangle[7], cz = triangle[8];
+    const px = point[point_offset], py = point[point_offset + 1], pz = point[point_offset + 2];
+
+    const e1x = bx - ax, e1y = by - ay, e1z = bz - az;
+    const e2x = cx - ax, e2y = cy - ay, e2z = cz - az;
+
+    const nx = e1y * e2z - e1z * e2y;
+    const ny = e1z * e2x - e1x * e2z;
+    const nz = e1x * e2y - e1y * e2x;
+
+    const nn = nx * nx + ny * ny + nz * nz;
+
+    if (!(nn > 0)) {
+        return FEATURE_NONE;
+    }
+
+    // weights of A and B: the signed areas of (P, B, C) and (P, C, A) over the triangle's
+    const pax = ax - px, pay = ay - py, paz = az - pz;
+    const pbx = bx - px, pby = by - py, pbz = bz - pz;
+    const pcx = cx - px, pcy = cy - py, pcz = cz - pz;
+
+    const wa = ((pby * pcz - pbz * pcy) * nx + (pbz * pcx - pbx * pcz) * ny + (pbx * pcy - pby * pcx) * nz) / nn;
+    const wb = ((pcy * paz - pcz * pay) * nx + (pcz * pax - pcx * paz) * ny + (pcx * pay - pcy * pax) * nz) / nn;
+    const wc = 1 - wa - wb;
+
+    // on edge k: the weight of the vertex across from it, k + 2, vanishes
+    const on_ab = wc <= ON_EDGE_WEIGHT;
+    const on_bc = wa <= ON_EDGE_WEIGHT;
+    const on_ca = wb <= ON_EDGE_WEIGHT;
+
+    if (on_ab) {
+        if (on_bc) return on_ca ? FEATURE_NONE : FEATURE_VERTEX_A + 1;
+        return on_ca ? FEATURE_VERTEX_A : FEATURE_EDGE_AB;
+    }
+
+    if (on_bc) {
+        return on_ca ? FEATURE_VERTEX_A + 2 : FEATURE_EDGE_AB + 1;
+    }
+
+    return on_ca ? FEATURE_EDGE_AB + 2 : FEATURE_FACE;
+}
+
+/** Bits of a float, for hashing coordinates. */
+const key_float = new Float64Array(1);
+const key_words = new Uint32Array(key_float.buffer);
+
+/**
+ * A set of points (width 3) or point pairs (width 6) keyed by their exact coordinates — the vertices
+ * and edges a concave dispatch has claimed. Open addressing; emptied by stamp, grown by doubling, the
+ * high-water mark kept.
+ */
+class CoordinateKeySet {
+    /**
+     * @param {number} width floats per key
+     */
+    constructor(width) {
+        this.width = width;
+        this.keys = new Float64Array(64 * width);
+        this.stamps = new Int32Array(64);
+        this.stamp = 1;
+        this.size = 0;
+
+        /** Rehash scratch: a caller's key must survive the growth its add triggers. */
+        this.rehash_key = new Float64Array(width);
+    }
+
+    clear() {
+        this.size = 0;
+        this.stamp++;
+
+        if (this.stamp === 0x7FFFFFFF) {
+            this.stamps.fill(0);
+            this.stamp = 1;
+        }
+    }
+
+    /**
+     * @param {Float64Array} key `width` floats
+     * @returns {number}
+     */
+    hash(key) {
+        let h = 0;
+
+        for (let i = 0; i < this.width; i++) {
+            // + 0 folds -0 into 0: equal coordinates must hash equal
+            key_float[0] = key[i] + 0;
+            h = Math.imul(h ^ key_words[0], 0x85EBCA6B) ^ Math.imul(key_words[1], 0xC2B2AE35);
+            h ^= h >>> 15;
+        }
+
+        return h;
+    }
+
+    /**
+     * Add a key.
+     * @param {Float64Array} key `width` floats
+     * @returns {boolean} whether it was not there before
+     */
+    add(key) {
+        if ((this.size + 1) * 2 > this.stamps.length) {
+            this.grow();
+        }
+
+        const width = this.width;
+        const mask = this.stamps.length - 1;
+
+        for (let slot = this.hash(key) & mask; ; slot = (slot + 1) & mask) {
+            if (this.stamps[slot] !== this.stamp) {
+                this.stamps[slot] = this.stamp;
+                this.keys.set(key, slot * width);
+                this.size++;
+                return true;
+            }
+
+            if (this.equals(slot, key)) {
+                return false;
+            }
+        }
+    }
+
+    /**
+     * @param {Float64Array} key `width` floats
+     * @returns {boolean}
+     */
+    has(key) {
+        const mask = this.stamps.length - 1;
+
+        for (let slot = this.hash(key) & mask; ; slot = (slot + 1) & mask) {
+            if (this.stamps[slot] !== this.stamp) {
+                return false;
+            }
+
+            if (this.equals(slot, key)) {
+                return true;
+            }
+        }
+    }
+
+    equals(slot, key) {
+        const width = this.width;
+        const o = slot * width;
+
+        for (let i = 0; i < width; i++) {
+            if (this.keys[o + i] !== key[i]) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    grow() {
+        const width = this.width;
+        const old_keys = this.keys;
+        const old_stamps = this.stamps;
+        const old_stamp = this.stamp;
+        const capacity = old_stamps.length * 2;
+
+        this.keys = new Float64Array(capacity * width);
+        this.stamps = new Int32Array(capacity);
+        this.stamp = 1;
+        this.size = 0;
+
+        const key = this.rehash_key;
+
+        for (let slot = 0; slot < old_stamps.length; slot++) {
+            if (old_stamps[slot] !== old_stamp) continue;
+
+            for (let i = 0; i < width; i++) key[i] = old_keys[slot * width + i];
+            this.add(key);
+        }
+    }
+}
+
+/** Key scratch: a vertex, and an edge with its end points in lexicographic order. */
+const key_vertex = new Float64Array(3);
+const key_edge = new Float64Array(6);
+
+/** Vertices and edges claimed in the sphere dispatch in progress (the sphere rule). */
+const claimed_vertices = new CoordinateKeySet(3);
+const claimed_edges = new CoordinateKeySet(6);
+
+/**
+ * Write vertex `k` of the triangle at `o` in {@link triangle_buffer} into {@link key_vertex}.
+ */
+function key_set_vertex(o, k) {
+    key_vertex[0] = triangle_buffer[o + k * 3];
+    key_vertex[1] = triangle_buffer[o + k * 3 + 1];
+    key_vertex[2] = triangle_buffer[o + k * 3 + 2];
+}
+
+/**
+ * Write edge `k` (vertex k to vertex k + 1) of the triangle at `o` in {@link triangle_buffer} into
+ * {@link key_edge}, its end points in lexicographic order so both triangles sharing it write one key.
+ */
+function key_set_edge(o, k) {
+    const p = o + k * 3;
+    const q = o + ((k + 1) % 3) * 3;
+
+    const px = triangle_buffer[p], py = triangle_buffer[p + 1], pz = triangle_buffer[p + 2];
+    const qx = triangle_buffer[q], qy = triangle_buffer[q + 1], qz = triangle_buffer[q + 2];
+
+    const p_first = px < qx || (px === qx && (py < qy || (py === qy && pz <= qz)));
+
+    if (p_first) {
+        key_edge[0] = px; key_edge[1] = py; key_edge[2] = pz;
+        key_edge[3] = qx; key_edge[4] = qy; key_edge[5] = qz;
+    } else {
+        key_edge[0] = qx; key_edge[1] = qy; key_edge[2] = qz;
+        key_edge[3] = px; key_edge[4] = py; key_edge[5] = pz;
+    }
+}
+
+/**
+ * Append tentative contact `t` unless an earlier contact of the dispatch repeats it.
+ * @param {number} count
+ * @param {number} t
+ * @returns {number}
+ */
+function tentative_append(count, t) {
+    const o = t * TENTATIVE_STRIDE;
+
+    if (dedup_contains(tentatives, o)) {
+        return count;
+    }
+
+    count = append_contact_record(count, tentatives, o);
+
+    dedup_insert(count - 1);
+
+    return count;
+}
+
+/**
+ * Box3D's sphere rule: tentative contacts closest first, each kept when the feature it touches is
+ * claimed for the first time; face contacts' triangles claim theirs before any. A kept one whose
+ * feature is FLAT is taken as the plane's, as everything else's is ({@link
+ * resolve_tentatives_by_features}): claims go by coordinates, and a neighbour whose copy of the edge
+ * is apart from this one's by float rounding, or that meets it at a T-junction, claims a different
+ * key.
+ *
+ * @param {number} count
+ * @param {AbstractShape3D} shape the concave shape the triangles are of
+ * @param {boolean} concave_is_a whether the concave shape is the contacts' A side
+ * @param {Transform64} concave_tr its pose
+ * @returns {number}
+ */
+function resolve_tentatives_by_claims(count, shape, concave_is_a, concave_tr) {
+    claimed_vertices.clear();
+    claimed_edges.clear();
+
+    for (let f = 0; f < face_triangle_count; f++) {
+        const o = face_triangles[f] * TRIANGLE_FLOAT_STRIDE;
+
+        for (let k = 0; k < 3; k++) {
+            key_set_vertex(o, k);
+            claimed_vertices.add(key_vertex);
+            key_set_edge(o, k);
+            claimed_edges.add(key_edge);
+        }
+    }
+
+    // closest first; a shell sort, as the tentatives are few and this allocates nothing
+    const n = tentative_count;
+    const order = tentative_order;
+
+    for (let t = 0; t < n; t++) order[t] = t;
+
+    for (let gap = n >> 1; gap > 0; gap >>= 1) {
+        for (let t = gap; t < n; t++) {
+            const v = order[t];
+            const key = tentatives[v * TENTATIVE_STRIDE + 13];
+
+            let s = t;
+
+            while (s >= gap && tentatives[order[s - gap] * TENTATIVE_STRIDE + 13] > key) {
+                order[s] = order[s - gap];
+                s -= gap;
+            }
+
+            order[s] = v;
+        }
+    }
+
+    for (let r = 0; r < n; r++) {
+        const t = order[r];
+        const o = t * TENTATIVE_STRIDE;
+        const tri = tentatives[o + 11] * TRIANGLE_FLOAT_STRIDE;
+        const feature = tentatives[o + 12];
+
+        // claim every vertex and edge of the triangle, noting whether the touched one is new
+        let fresh = feature === FEATURE_FACE;
+
+        for (let k = 0; k < 3; k++) {
+            key_set_vertex(tri, k);
+            if (claimed_vertices.add(key_vertex) && feature === FEATURE_VERTEX_A + k) fresh = true;
+
+            key_set_edge(tri, k);
+            if (claimed_edges.add(key_edge) && feature === FEATURE_EDGE_AB + k) fresh = true;
+        }
+
+        if (!fresh) {
+            continue;
+        }
+
+        if (feature_is_flat(shape, tri, feature)) {
+            triangle_plane_world(tri, concave_tr);
+            count = tentative_append_on_plane(count, t, concave_is_a);
+        } else {
+            count = tentative_append(count, t);
+        }
+    }
+
+    return count;
+}
+
+/**
+ * Whether `feature` of the triangle at float index `tri` of {@link triangle_buffer} is no feature of
+ * the surface: the face, a FLAT edge, a FLAT corner.
+ * @param {AbstractShape3D} shape
+ * @param {number} tri
+ * @param {number} feature
+ * @returns {boolean}
+ */
+function feature_is_flat(shape, tri, feature) {
+    if (feature === FEATURE_FACE) {
+        return true;
+    }
+
+    if (feature < FEATURE_VERTEX_A) {
+        return (triangle_edge_flags(shape, triangle_buffer, tri) & (TriangleEdgeFlags.FlatAB << feature)) !== 0;
+    }
+
+    if (feature < FEATURE_FACE) {
+        return triangle_vertex_flat(shape, triangle_buffer, tri, feature - FEATURE_VERTEX_A);
+    }
+
+    return false;
+}
+
+/**
+ * A triangle's plane, from {@link triangle_plane_world}: its unit outward normal (world) at 0..2, the
+ * plane's offset along it at 3, and its corners (world) at 4..12.
+ */
+const tri_plane = new Float64Array(13);
+
+/**
+ * The plane of the triangle at float index `tri` of {@link triangle_buffer}, posed by `concave_tr`,
+ * into {@link tri_plane}.
+ * @param {number} tri
+ * @param {Transform64} concave_tr
+ */
+function triangle_plane_world(tri, concave_tr) {
+    pose_pack(plane_pose, concave_tr);
+    triangle_vertices_to_world(scratch_tri_world, triangle_buffer, tri, plane_pose);
+
+    const w = scratch_tri_world;
+    const e1x = w[3] - w[0], e1y = w[4] - w[1], e1z = w[5] - w[2];
+    const e2x = w[6] - w[0], e2y = w[7] - w[1], e2z = w[8] - w[2];
+    const nx = e1y * e2z - e1z * e2y, ny = e1z * e2x - e1x * e2z, nz = e1x * e2y - e1y * e2x;
+    const inv = 1 / Math.sqrt(nx * nx + ny * ny + nz * nz);
+
+    tri_plane[0] = nx * inv;
+    tri_plane[1] = ny * inv;
+    tri_plane[2] = nz * inv;
+    tri_plane[3] = tri_plane[0] * w[0] + tri_plane[1] * w[1] + tri_plane[2] * w[2];
+
+    for (let i = 0; i < 9; i++) {
+        tri_plane[4 + i] = w[i];
+    }
+}
+
+/**
+ * The round core of the dispatch's convex body, for {@link plane_witness_of}: every point of a
+ * sphere's or a capsule's surface lies `round_core[ROUND_RADIUS]` from its core segment (world, from
+ * `ROUND_P0` to `ROUND_P1`; a sphere's has no length). A radius of 0: the body has corners, or no core
+ * known here. In an array, not module `let`s: a number written to a module `let` is boxed.
+ *
+ * `round_core[ROUND_HALF]` is the core's half-length, staged with the radius for
+ * {@link round_core_place}.
+ */
+const ROUND_RADIUS = 0;
+const ROUND_P0 = 1;
+const ROUND_P1 = 4;
+const ROUND_HALF = 7;
+const round_core = new Float64Array(8);
+
+/**
+ * Place the round core of the dispatch's convex body, whose radius and half-length the caller has
+ * staged at ROUND_RADIUS and ROUND_HALF: `half` along its local y either side of its centre,
+ * `radius` out from that. They are staged rather than passed because the call is not inlined into
+ * dispatch_pair, and it would box the two numbers.
+ * @param {Transform64} tr the body's pose
+ */
+function round_core_place(tr) {
+    const half = round_core[ROUND_HALF];
+
+    // q · (0, half, 0) · q*
+    const qx = tr[TRANSFORM64_ROTATION_OFFSET], qy = tr[TRANSFORM64_ROTATION_OFFSET + 1];
+    const qz = tr[TRANSFORM64_ROTATION_OFFSET + 2], qw = tr[TRANSFORM64_ROTATION_OFFSET + 3];
+    const ax = 2 * (qx * qy - qw * qz) * half;
+    const ay = (1 - 2 * (qx * qx + qz * qz)) * half;
+    const az = 2 * (qy * qz + qw * qx) * half;
+
+    const px = tr[TRANSFORM64_TRANSLATION_OFFSET];
+    const py = tr[TRANSFORM64_TRANSLATION_OFFSET + 1];
+    const pz = tr[TRANSFORM64_TRANSLATION_OFFSET + 2];
+
+    round_core[ROUND_P0] = px - ax;
+    round_core[ROUND_P0 + 1] = py - ay;
+    round_core[ROUND_P0 + 2] = pz - az;
+    round_core[ROUND_P1] = px + ax;
+    round_core[ROUND_P1 + 1] = py + ay;
+    round_core[ROUND_P1 + 2] = pz + az;
+}
+
+/** The convex body's point touching the plane, of the contact {@link tentative_append_on_plane} is making. */
+const plane_witness = new Float64Array(3);
+
+/**
+ * Where the convex body touches a plane of outward normal f, near its witness `(bx, by, bz)` of a
+ * contact along some other normal — into {@link plane_witness}.
+ *
+ * A body with corners touches with the same corner or edge point whichever way the normal turns, so
+ * the witness stays. A round body does not: its witness slides around its surface with the normal,
+ * and its point touching the plane is the one under its core, `radius` along -f from the core point
+ * nearest the witness. Left where it was, the witness of a capsule touching a flat edge a few
+ * millimetres off the line under its axis put the plane's push there, off the axis, and a
+ * frictionless capsule sliding across a triangulated floor picked up spin at every edge — 0.1 to
+ * 0.5 rad/s, where a box floor leaves it none.
+ */
+function plane_witness_of(bx, by, bz, fx, fy, fz) {
+    const round_radius = round_core[ROUND_RADIUS];
+
+    if (round_radius === 0) {
+        plane_witness[0] = bx;
+        plane_witness[1] = by;
+        plane_witness[2] = bz;
+        return;
+    }
+
+    const round_x0 = round_core[ROUND_P0], round_y0 = round_core[ROUND_P0 + 1], round_z0 = round_core[ROUND_P0 + 2];
+    const round_x1 = round_core[ROUND_P1], round_y1 = round_core[ROUND_P1 + 1], round_z1 = round_core[ROUND_P1 + 2];
+
+    const sx = round_x1 - round_x0, sy = round_y1 - round_y0, sz = round_z1 - round_z0;
+    const ss = sx * sx + sy * sy + sz * sz;
+
+    let u = ss > 0 ? ((bx - round_x0) * sx + (by - round_y0) * sy + (bz - round_z0) * sz) / ss : 0;
+    u = u < 0 ? 0 : u > 1 ? 1 : u;
+
+    plane_witness[0] = round_x0 + sx * u - fx * round_radius;
+    plane_witness[1] = round_y0 + sy * u - fy * round_radius;
+    plane_witness[2] = round_z0 + sz * u - fz * round_radius;
+}
+
+/**
+ * Whether a point of the plane in {@link tri_plane} lies on its triangle, to {@link ON_EDGE_WEIGHT}
+ * of its barycentric weights.
+ * @param {Float64Array} point
+ * @param {number} point_offset
+ * @returns {boolean}
+ */
+function tri_plane_contains(point, point_offset) {
+    const px = point[point_offset], py = point[point_offset + 1], pz = point[point_offset + 2];
+
+    const ax = tri_plane[4], ay = tri_plane[5], az = tri_plane[6];
+    const bx = tri_plane[7], by = tri_plane[8], bz = tri_plane[9];
+    const cx = tri_plane[10], cy = tri_plane[11], cz = tri_plane[12];
+
+    const e1x = bx - ax, e1y = by - ay, e1z = bz - az;
+    const e2x = cx - ax, e2y = cy - ay, e2z = cz - az;
+    const nx = e1y * e2z - e1z * e2y, ny = e1z * e2x - e1x * e2z, nz = e1x * e2y - e1y * e2x;
+    const nn = nx * nx + ny * ny + nz * nz;
+
+    if (!(nn > 0)) {
+        return false;
+    }
+
+    // the weights of A and B: the signed areas of (P, B, C) and (P, C, A) over the triangle's
+    const pax = ax - px, pay = ay - py, paz = az - pz;
+    const pbx = bx - px, pby = by - py, pbz = bz - pz;
+    const pcx = cx - px, pcy = cy - py, pcz = cz - pz;
+
+    const wa = ((pby * pcz - pbz * pcy) * nx + (pbz * pcx - pbx * pcz) * ny + (pbx * pcy - pby * pcx) * nz) / nn;
+    const wb = ((pcy * paz - pcz * pay) * nx + (pcz * pax - pcx * paz) * ny + (pcx * pay - pcy * pax) * nz) / nn;
+
+    return wa >= -ON_EDGE_WEIGHT && wb >= -ON_EDGE_WEIGHT && 1 - wa - wb >= -ON_EDGE_WEIGHT;
+}
+
+/**
+ * Append tentative contact `t` as a contact with the plane of its triangle, the one in {@link
+ * tri_plane}: the normal the triangle's, the depth below that plane of the convex body's point touching
+ * it ({@link plane_witness_of}), the triangle's witness that point's projection onto it. Not appended
+ * when the point is not below the plane, nor for a round body whose point projects off the triangle and
+ * whose contact's own normal is more than a flat edge's bend off the plane's.
+ *
+ * The plane is the one in {@link tri_plane}: its unit outward normal f (world) and its offset along
+ * it, `f · p` for any point p of it.
+ *
+ * @param {number} count
+ * @param {number} t
+ * @param {boolean} concave_is_a whether the triangle is the contact's A side
+ * @returns {number}
+ */
+function tentative_append_on_plane(count, t, concave_is_a) {
+    const fx = tri_plane[0], fy = tri_plane[1], fz = tri_plane[2];
+    const plane = tri_plane[3];
+
+    const o = t * TENTATIVE_STRIDE;
+
+    // the convex body's witness, moved to where it touches the plane
+    const bo = concave_is_a ? o + 3 : o;
+    plane_witness_of(tentatives[bo], tentatives[bo + 1], tentatives[bo + 2], fx, fy, fz);
+    const bx = plane_witness[0], by = plane_witness[1], bz = plane_witness[2];
+
+    const depth = plane - (fx * bx + fy * by + fz * bz);
+
+    if (!(depth > 0)) {
+        return count;
+    }
+
+    const px = bx + fx * depth, py = by + fy * depth, pz = bz + fz * depth;
+
+    // the contact, staged: the triangle's point is A's witness when the triangle is A
+    const c = staged_contact;
+    const p_offset = concave_is_a ? 0 : 3;
+    const b_offset = concave_is_a ? 3 : 0;
+
+    c[p_offset] = px; c[p_offset + 1] = py; c[p_offset + 2] = pz;
+    c[b_offset] = bx; c[b_offset + 1] = by; c[b_offset + 2] = bz;
+
+    // A round body's point under its core, off this triangle, and the contact meeting the feature from
+    // further off this plane's normal than a flat edge bends: the body is not on this face. A capsule over
+    // a 1 cm step touched the riser's internal diagonal from above, and taken as the riser's plane that
+    // contact pushed it back by its whole 8 cm intrusion into the plane, which there is not the surface.
+    // Nearer the plane's normal it is the plane's, off the triangle or not: on a convex crease flatter
+    // than a flat edge's bend, the point lies past the crease on either side, off both triangles, and
+    // neither holds the body. Dropped on both, a sphere set on a 1° roof's ridge fell through it.
+    if (round_core[ROUND_RADIUS] !== 0 && !tri_plane_contains(c, p_offset)
+        && Math.abs(tentatives[o + 6] * fx + tentatives[o + 7] * fy + tentatives[o + 8] * fz) < FLAT_EDGE_COS) {
+        return count;
+    }
+
+    // stored B → A: the triangle is A, so toward it
+    c[6] = concave_is_a ? -fx : fx;
+    c[7] = concave_is_a ? -fy : fy;
+    c[8] = concave_is_a ? -fz : fz;
+    c[9] = depth;
+    c[10] = tentatives[o + 10];
+
+    if (dedup_contains(c, 0)) {
+        return count;
+    }
+
+    count = append_contact_record(count, c, 0);
+
+    dedup_insert(count - 1);
+
+    return count;
+}
+
+/**
+ * The rule for everything but a sphere: a tentative contact lying inside its triangle, or on an edge or
+ * a corner of it that is FLAT, touches no feature of the surface — the surface there is the plane — and
+ * is taken as a contact with the triangle's plane ({@link tentative_append_on_plane}). One on a real
+ * edge or a real corner is kept as it is. See "Internal edges".
+ *
+ * @param {number} count
+ * @param {AbstractShape3D} shape the concave shape the triangles are of
+ * @param {boolean} concave_is_a whether the concave shape is the contacts' A side
+ * @param {Transform64} concave_tr its pose
+ * @returns {number}
+ */
+function resolve_tentatives_by_features(count, shape, concave_is_a, concave_tr) {
+    // a triangle's tentative contacts arrive together: classify its edges, and find its plane, once
+    let edges_tri = -1, edges = 0;
+    let plane_tri = -1;
+
+    for (let t = 0; t < tentative_count; t++) {
+        const o = t * TENTATIVE_STRIDE;
+        const tri = tentatives[o + 11] * TRIANGLE_FLOAT_STRIDE;
+        const feature = tentatives[o + 12];
+
+        let flat;
+
+        if (feature < FEATURE_VERTEX_A) {
+            if (edges_tri !== tri) {
+                edges = triangle_edge_flags(shape, triangle_buffer, tri);
+                edges_tri = tri;
+            }
+
+            flat = (edges & (TriangleEdgeFlags.FlatAB << feature)) !== 0;
+        } else {
+            flat = feature_is_flat(shape, tri, feature);
+        }
+
+        if (!flat) {
+            count = tentative_append(count, t);
+            continue;
+        }
+
+        if (plane_tri !== tri) {
+            triangle_plane_world(tri, concave_tr);
+            plane_tri = tri;
+        }
+
+        count = tentative_append_on_plane(count, t, concave_is_a);
+    }
+
+    return count;
+}
+/**
+ * Most triangles one concave-vs-convex pair is collided against: the bound
+ * on {@link triangle_buffer}'s growth (65,536 triangles, 5 MiB of scratch).
+ *
+ * The count is the convex side's footprint over the concave side's
+ * triangle density, not a property of the pair kind: a 4 m crate on a
+ * floor meshed at 10 cm covers some 3,500 triangles, an 8 m box on a
+ * tessellated heightmap 32,768. The buffer used to be a fixed 1,024 and
+ * the overflow was dropped — a drop that is not "a far edge", because the
+ * enumerators emit in index (mesh) or row (heightmap) order, so what was
+ * lost was every triangle past a line through the footprint. The crate
+ * kept the triangles under one side, tipped about that line, and fell
+ * through the floor, the same way every step.
+ *
+ * Past this bound the rest of the pair's triangles are not collided
+ * against, and the first time it happens the process is told so.
+ *
+ * @type {number}
+ */
+const MAX_TRIANGLES_PER_PAIR = 1 << 16;
+
+/**
+ * Per-pair scratch for the concave-side triangle decomposition. Grows (by
+ * doubling, re-enumerating once) when a pair overlaps more triangles than
+ * it holds, up to {@link MAX_TRIANGLES_PER_PAIR}; the high-water mark is
+ * kept for the process.
+ *
+ * Enumerators return the TRUE overlap count and drop writes past the
+ * buffer's end (typed-array OOB semantics), so the consume loop must never
+ * run past the capacity — it would read `undefined` and poison the
+ * manifold with NaN.
  * @type {Float64Array}
  */
-const triangle_buffer = new Float64Array(MAX_TRIANGLES_PER_PAIR * TRIANGLE_FLOAT_STRIDE);
+let triangle_buffer = new Float64Array(1024 * TRIANGLE_FLOAT_STRIDE);
+
+/**
+ * Whether a pair overlapping more than {@link MAX_TRIANGLES_PER_PAIR}
+ * triangles has been reported. Once per process: the condition belongs to
+ * the content, and it would recur every substep.
+ * @type {boolean}
+ */
+let triangle_overflow_reported = false;
 
 /**
  * Flyweight triangle shape — rebound to each successive triangle slice
@@ -290,8 +1411,25 @@ const concave_query_aabb = new Float64Array(6);
  *
  * Shared by the sphere / box / capsule closed-form triangle fast-paths in
  * the concave dispatch, which each carried an identical inlined copy.
+ *
+ * The vertices and the pose are read from arrays: the dispatch calls this
+ * per triangle from more sites than it can inline, and a call that is not
+ * inlined boxes each number passed to it — sixteen per triangle.
+ *
+ * @param {Float64Array} out
+ * @param {Float64Array} triangle local vertices A, B, C
+ * @param {number} triangle_offset
+ * @param {Float64Array} pose the concave body's position then orientation:
+ *   `[px, py, pz, qx, qy, qz, qw]`
  */
-function triangle_vertices_to_world(out, ax, ay, az, bx, by, bz, cx, cy, cz, qx, qy, qz, qw, px, py, pz) {
+function triangle_vertices_to_world(out, triangle, triangle_offset, pose) {
+    const ax = triangle[triangle_offset], ay = triangle[triangle_offset + 1], az = triangle[triangle_offset + 2];
+    const bx = triangle[triangle_offset + 3], by = triangle[triangle_offset + 4], bz = triangle[triangle_offset + 5];
+    const cx = triangle[triangle_offset + 6], cy = triangle[triangle_offset + 7], cz = triangle[triangle_offset + 8];
+
+    const px = pose[0], py = pose[1], pz = pose[2];
+    const qx = pose[3], qy = pose[4], qz = pose[5], qw = pose[6];
+
     const axi =  qw * ax + qy * az - qz * ay;
     const ayi =  qw * ay + qz * ax - qx * az;
     const azi =  qw * az + qx * ay - qy * ax;
@@ -323,6 +1461,195 @@ function triangle_vertices_to_world(out, ax, ay, az, bx, by, bz, cx, cy, cz, qx,
 /** Destination for {@link triangle_vertices_to_world}. */
 const scratch_tri_world = new Float64Array(9);
 
+/**
+ * Poses, `[px, py, pz, qx, qy, qz, qw]`: the concave and the convex body's in the concave dispatch,
+ * packed once per dispatch, and {@link triangle_plane_world}'s.
+ */
+const concave_pose = new Float64Array(7);
+const convex_pose = new Float64Array(7);
+const plane_pose = new Float64Array(7);
+
+/**
+ * The concave dispatch's convex body, packed once per dispatch for the closed-form triangle kernels'
+ * array forms: a box's centre, orientation and half-extents (10); a sphere's centre and radius (4); a
+ * capsule's centre, orientation, radius and half-height (9).
+ */
+const convex_record = new Float64Array(10);
+
+/**
+ * Pack a pose, `[px, py, pz, qx, qy, qz, qw]`, from a transform.
+ *
+ * Read off the transform's lanes (a Transform64 is a Float64Array), not through `translation_x` and
+ * the rest: inlined into dispatch_pair, those accessor calls land on a branch too rarely taken for
+ * TurboFan to inline them, and each then returns its number boxed.
+ *
+ * @param {Float64Array} out
+ * @param {Transform64} tr
+ */
+function pose_pack(out, tr) {
+    out[0] = tr[TRANSFORM64_TRANSLATION_OFFSET];
+    out[1] = tr[TRANSFORM64_TRANSLATION_OFFSET + 1];
+    out[2] = tr[TRANSFORM64_TRANSLATION_OFFSET + 2];
+    out[3] = tr[TRANSFORM64_ROTATION_OFFSET];
+    out[4] = tr[TRANSFORM64_ROTATION_OFFSET + 1];
+    out[5] = tr[TRANSFORM64_ROTATION_OFFSET + 2];
+    out[6] = tr[TRANSFORM64_ROTATION_OFFSET + 3];
+}
+
+// dispatch_pair branches on the shape pair, so each branch runs on a fraction of its calls: too few
+// for TurboFan to inline a call made there, small or not, and a call that is not inlined boxes each
+// number handed to it. The closed-form pair kernels therefore get their bodies packed into these
+// records, and their contacts are appended from arrays.
+
+/** dispatch_pair's boxes, `[px, py, pz, qx, qy, qz, qw, hx, hy, hz]`. */
+const pair_box_a = new Float64Array(10);
+const pair_box_b = new Float64Array(10);
+
+/** dispatch_pair's spheres, `[px, py, pz, radius]`. */
+const pair_sphere_a = new Float64Array(4);
+const pair_sphere_b = new Float64Array(4);
+
+/** dispatch_pair's capsules, `[px, py, pz, qx, qy, qz, qw, radius, half_height]`. */
+const pair_capsule_a = new Float64Array(9);
+const pair_capsule_b = new Float64Array(9);
+
+/** A hull's pose, `[px, py, pz, qx, qy, qz, qw]`, for the hull-sphere kernel. */
+const pair_pose = new Float64Array(7);
+
+/** The two poses of a hull pair, for {@link hull_pair_contacts}. */
+const pair_pose_a = new Float64Array(7);
+const pair_pose_b = new Float64Array(7);
+
+/** One contact for {@link append_contact_record}, staged by dispatch_pair's closed-form branches. */
+const pair_contact = new Float64Array(11);
+
+/**
+ * Pack a sphere record, `[px, py, pz, radius]`.
+ * @param {Float64Array} out
+ * @param {Transform64} tr
+ * @param {SphereShape3D} shape
+ */
+function sphere_record_pack(out, tr, shape) {
+    out[0] = tr[TRANSFORM64_TRANSLATION_OFFSET];
+    out[1] = tr[TRANSFORM64_TRANSLATION_OFFSET + 1];
+    out[2] = tr[TRANSFORM64_TRANSLATION_OFFSET + 2];
+    out[3] = shape.radius;
+}
+
+/**
+ * Pack a capsule record, `[px, py, pz, qx, qy, qz, qw, radius, half_height]`.
+ * @param {Float64Array} out
+ * @param {Transform64} tr
+ * @param {CapsuleShape3D} shape
+ */
+function capsule_record_pack(out, tr, shape) {
+    pose_pack(out, tr);
+    out[7] = shape.radius;
+    out[8] = shape.height * 0.5;
+}
+
+/**
+ * Append a closed-form contact from a result laid out `[normal, depth, witness 1, witness 2]` — the
+ * sphere-box, capsule-sphere and hull-sphere kernels' layout, whose normal points from witness 2's
+ * body toward witness 1's.
+ *
+ * @param {number} count
+ * @param {Float64Array} result
+ * @param {boolean} first_is_a witness 1 is on A; else the witnesses swap and the normal turns round
+ * @param {number} feature_id
+ * @returns {number}
+ */
+function append_closed_form_contact(count, result, first_is_a, feature_id) {
+    const c = pair_contact;
+
+    if (first_is_a) {
+        c[0] = result[4]; c[1] = result[5]; c[2] = result[6];
+        c[3] = result[7]; c[4] = result[8]; c[5] = result[9];
+        c[6] = result[0]; c[7] = result[1]; c[8] = result[2];
+    } else {
+        c[0] = result[7]; c[1] = result[8]; c[2] = result[9];
+        c[3] = result[4]; c[4] = result[5]; c[5] = result[6];
+        c[6] = -result[0]; c[7] = -result[1]; c[8] = -result[2];
+    }
+
+    c[9] = result[3];
+    c[10] = feature_id;
+
+    return append_contact_record(count, c, 0);
+}
+
+/**
+ * Append contact `offset` of a multi-contact result laid out `[witness 1, witness 2, normal, depth]`
+ * per contact — the capsule-capsule and capsule-box kernels' layout, whose normal points from
+ * witness 2's body toward witness 1's.
+ *
+ * @param {number} count
+ * @param {Float64Array} result
+ * @param {number} offset
+ * @param {boolean} first_is_a witness 1 is on A; else the witnesses swap and the normal turns round
+ * @param {number} feature_id
+ * @returns {number}
+ */
+function append_manifold_contact(count, result, offset, first_is_a, feature_id) {
+    const c = pair_contact;
+
+    if (first_is_a) {
+        c[0] = result[offset];     c[1] = result[offset + 1]; c[2] = result[offset + 2];
+        c[3] = result[offset + 3]; c[4] = result[offset + 4]; c[5] = result[offset + 5];
+        c[6] = result[offset + 6]; c[7] = result[offset + 7]; c[8] = result[offset + 8];
+    } else {
+        c[0] = result[offset + 3]; c[1] = result[offset + 4]; c[2] = result[offset + 5];
+        c[3] = result[offset];     c[4] = result[offset + 1]; c[5] = result[offset + 2];
+        c[6] = -result[offset + 6]; c[7] = -result[offset + 7]; c[8] = -result[offset + 8];
+    }
+
+    c[9] = result[offset + 9];
+    c[10] = feature_id;
+
+    return append_contact_record(count, c, 0);
+}
+
+/**
+ * Pack a box record, `[px, py, pz, qx, qy, qz, qw, hx, hy, hz]`: its centre and orientation from the
+ * transform, then its half-extents, read off their lanes for {@link pose_pack}'s reason (a Vector3 is
+ * a Float64Array).
+ * @param {Float64Array} out
+ * @param {Transform64} tr
+ * @param {Vector3} half_extents
+ */
+function box_record_pack(out, tr, half_extents) {
+    pose_pack(out, tr);
+    out[7] = half_extents[0];
+    out[8] = half_extents[1];
+    out[9] = half_extents[2];
+}
+
+/**
+ * Append contact `offset` of a box-box or convex-convex manifold (the layout is shared) — A witness,
+ * B witness, depth, after the manifold's shared normal at [0..2] — with no feature id.
+ * @param {number} count
+ * @param {Float64Array} manifold a {@link box_box_manifold_array} or {@link convex_hull_clip_array} result
+ * @param {number} offset
+ * @returns {number}
+ */
+function append_box_manifold_contact(count, manifold, offset) {
+    const c = pair_contact;
+
+    c[0] = manifold[offset];
+    c[1] = manifold[offset + 1];
+    c[2] = manifold[offset + 2];
+    c[3] = manifold[offset + 3];
+    c[4] = manifold[offset + 4];
+    c[5] = manifold[offset + 5];
+    c[6] = manifold[0];
+    c[7] = manifold[1];
+    c[8] = manifold[2];
+    c[9] = manifold[offset + 6];
+    c[10] = 0;
+
+    return append_contact_record(count, c, 0);
+}
+
 /**
  * Append one contact to the candidate buffer. Returns the new count.
  *
@@ -360,6 +1687,37 @@ function append_contact(count, wax, way, waz, wbx, wby, wbz, nx, ny, nz, depth,
     return count + 1;
 }
 
+/**
+ * {@link append_contact} with the contact read from a record laid out as append_contact takes it —
+ * A witness, B witness, stored normal, depth, feature id — at `offset`: for the concave dispatch's
+ * per-triangle contacts, where a call that is not inlined would box all eleven. (append_contact keeps
+ * its own copy of the stores rather than packing for this: as it is, the contact producers that take
+ * it as their callback inline it.)
+ *
+ * @param {number} count
+ * @param {Float64Array} contact
+ * @param {number} offset
+ * @returns {number}
+ */
+function append_contact_record(count, contact, offset) {
+    if (count * CANDIDATE_STRIDE >= candidates.length){
+        grow_candidates();
+    }
+
+    const off = count * CANDIDATE_STRIDE;
+
+    candidates[off]     = contact[offset];     candidates[off + 1] = contact[offset + 1]; candidates[off + 2] = contact[offset + 2];
+    candidates[off + 3] = contact[offset + 3]; candidates[off + 4] = contact[offset + 4]; candidates[off + 5] = contact[offset + 5];
+    candidates[off + 6] = contact[offset + 6]; candidates[off + 7] = contact[offset + 7]; candidates[off + 8] = contact[offset + 8];
+    candidates[off + 9] = contact[offset + 9];
+    candidates[off + 10] = contact[offset + 10];
+    candidates[off + 11] = g_pair_friction;
+    candidates[off + 12] = g_pair_restitution;
+    candidates[off + 13] = g_pair_flags;
+
+    return count + 1;
+}
+
 /**
  * Compute a stable voronoi-region feature id for a sphere-vs-box contact.
  * Returns one of 27 values in `[1, 27]` based on which of the 27 voronoi
@@ -375,22 +1733,22 @@ function append_contact(count, wax, way, waz, wbx, wby, wbz, nx, ny, nz, depth,
  * The "+1" offset ensures the result is never 0, since 0 is reserved
  * for "no feature info, use position-fallback".
  *
- * @param {number} sx sphere centre x
- * @param {number} sy
- * @param {number} sz
- * @param {number} bx box centre x
- * @param {number} by
- * @param {number} bz
- * @param {number} bqx box quaternion x
- * @param {number} bqy
- * @param {number} bqz
- * @param {number} bqw
- * @param {number} hx box half-extent x
- * @param {number} hy
- * @param {number} hz
+ * The sphere and the box are read from their records (see {@link sphere_record_pack} and
+ * {@link box_record_pack}): this is called from a dispatch_pair branch, where the thirteen numbers
+ * would each be boxed into a new heap object.
+ *
+ * @param {Float64Array} sphere `[centre, radius]`
+ * @param {number} sphere_offset
+ * @param {Float64Array} box `[centre, orientation, half-extents]`
+ * @param {number} box_offset
  * @returns {number}
  */
-function sphere_box_voronoi_fid(sx, sy, sz, bx, by, bz, bqx, bqy, bqz, bqw, hx, hy, hz) {
+function sphere_box_voronoi_fid_array(sphere, sphere_offset, box, box_offset) {
+    const sx = sphere[sphere_offset], sy = sphere[sphere_offset + 1], sz = sphere[sphere_offset + 2];
+    const bx = box[box_offset], by = box[box_offset + 1], bz = box[box_offset + 2];
+    const bqx = box[box_offset + 3], bqy = box[box_offset + 4], bqz = box[box_offset + 5], bqw = box[box_offset + 6];
+    const hx = box[box_offset + 7], hy = box[box_offset + 8], hz = box[box_offset + 9];
+
     // Inverse-rotate (sx - bx, sy - by, sz - bz) by the box's quaternion
     // to get the sphere centre in box-local frame. Inlined for the same
     // V8-inliner reason described in PosedShape3D.support — see
@@ -430,45 +1788,182 @@ function sphere_box_voronoi_fid(sx, sy, sz, bx, by, bz, bqx, bqy, bqz, bqw, hx,
  * @param {Transform64} trA
  * @param {{vertices,face_offsets,face_loops,support}} hullB  in B's local frame
  * @param {Transform64} trB
- * @param {Function} append_contact
  * @returns {number}
  */
-function hull_pair_contacts(count, hullA, trA, hullB, trB, append_contact) {
-    posed_a.setup_components(
-        hullA,
-        trA.translation_x, trA.translation_y, trA.translation_z,
-        trA.rotation_x, trA.rotation_y, trA.rotation_z, trA.rotation_w
-    );
-    posed_b.setup_components(
-        hullB,
-        trB.translation_x, trB.translation_y, trB.translation_z,
-        trB.rotation_x, trB.rotation_y, trB.rotation_z, trB.rotation_w
-    );
+function hull_pair_contacts(count, hullA, trA, hullB, trB) {
+    // Poses go to the posed shapes and the clip in arrays, read off the transforms' lanes: this is
+    // called from a dispatch_pair branch, and numbers handed across a call there are boxed.
+    pose_pack(pair_pose_a, trA);
+    pose_pack(pair_pose_b, trB);
+    posed_a.setup_pose(hullA, pair_pose_a, 0);
+    posed_b.setup_pose(hullB, pair_pose_b, 0);
     const depth = gjk_epa_penetration(epa_result, posed_a, posed_b);
     if (!(depth > 0) || !Number.isFinite(depth)) return count;
 
+    hull_position_a[0] = pair_pose_a[0];
+    hull_position_a[1] = pair_pose_a[1];
+    hull_position_a[2] = pair_pose_a[2];
+    hull_rotation_a[0] = pair_pose_a[3];
+    hull_rotation_a[1] = pair_pose_a[4];
+    hull_rotation_a[2] = pair_pose_a[5];
+    hull_rotation_a[3] = pair_pose_a[6];
+
+    hull_position_b[0] = pair_pose_b[0];
+    hull_position_b[1] = pair_pose_b[1];
+    hull_position_b[2] = pair_pose_b[2];
+    hull_rotation_b[0] = pair_pose_b[3];
+    hull_rotation_b[1] = pair_pose_b[4];
+    hull_rotation_b[2] = pair_pose_b[5];
+    hull_rotation_b[3] = pair_pose_b[6];
+
     // convex_hull_clip orients the axis B→A robustly (via vertex centroids) and
     // writes the final normal into convex_manifold_result[0..2].
-    convex_hull_clip(convex_manifold_result,
-        hullA, trA.translation, trA.rotation,
-        hullB, trB.translation, trB.rotation,
-        epa_result[0], epa_result[1], epa_result[2]);
-    const nx = convex_manifold_result[0], ny = convex_manifold_result[1], nz = convex_manifold_result[2];
+    convex_hull_clip_array(convex_manifold_result,
+        hullA, hull_position_a, hull_rotation_a,
+        hullB, hull_position_b, hull_rotation_b,
+        epa_result, 0);
     const cc = convex_manifold_result[3] | 0;
     // Clipped points migrate across features as the hulls rotate, so leave
     // fid = 0 and let the match-and-merge pass position-match (as box-box does).
     for (let k = 0; k < cc; k++) {
-        const base = 4 + k * 7;
-        count = append_contact(count,
-            convex_manifold_result[base],     convex_manifold_result[base + 1], convex_manifold_result[base + 2],
-            convex_manifold_result[base + 3], convex_manifold_result[base + 4], convex_manifold_result[base + 5],
-            nx, ny, nz,
-            convex_manifold_result[base + 6],
-            0);
+        count = append_box_manifold_contact(count, convex_manifold_result, 4 + k * 7);
     }
     return count;
 }
 
+/**
+ * A box as a polytope, for {@link hull_pair_contacts}: corners `(±hx, ±hy, ±hz)` numbered
+ * 0 −−−, 1 +−−, 2 ++−, 3 −+−, 4 −−+, 5 +−+, 6 +++, 7 −++ (the −z face's square, then the +z face's),
+ * six quad faces wound CCW from outside, and the exact box support. {@link box_polytope_set} sizes it
+ * before each use.
+ */
+class BoxPolytope {
+    vertices = new Float64Array(24);
+    face_offsets = new Uint32Array([0, 4, 8, 12, 16, 20, 24]);
+    face_loops = new Uint32Array([
+        1, 2, 6, 5, // +X
+        0, 4, 7, 3, // -X
+        3, 7, 6, 2, // +Y
+        0, 1, 5, 4, // -Y
+        4, 5, 6, 7, // +Z
+        0, 3, 2, 1, // -Z
+    ]);
+
+    // a typed array, not three number fields: a double field of a plain object is a heap box, and
+    // reading one in the GJK support loop allocated ~320 B per dispatch
+    half_extents = new Float64Array(3);
+
+    support(result, result_offset, direction, direction_offset) {
+        const dx = direction[direction_offset];
+        const dy = direction[direction_offset + 1];
+        const dz = direction[direction_offset + 2];
+
+        const h = this.half_extents;
+        result[result_offset] = dx >= 0 ? h[0] : -h[0];
+        result[result_offset + 1] = dy >= 0 ? h[1] : -h[1];
+        result[result_offset + 2] = dz >= 0 ? h[2] : -h[2];
+    }
+}
+
+const box_polytope = new BoxPolytope();
+
+/**
+ * Size {@link box_polytope} to a box's half-extents.
+ * @param {{x: number, y: number, z: number}} half_extents
+ */
+function box_polytope_set(half_extents) {
+    const hx = half_extents.x, hy = half_extents.y, hz = half_extents.z;
+    const v = box_polytope.vertices;
+    const h = box_polytope.half_extents;
+
+    h[0] = hx;
+    h[1] = hy;
+    h[2] = hz;
+
+    for (let i = 0; i < 8; i++) {
+        // +x at corners 1, 2, 5, 6; +y at 2, 3, 6, 7; +z at 4..7
+        const px = (i === 1 || i === 2 || i === 5 || i === 6) ? hx : -hx;
+        const py = (i === 2 || i === 3 || i === 6 || i === 7) ? hy : -hy;
+        const pz = i >= 4 ? hz : -hz;
+
+        v[i * 3] = px;
+        v[i * 3 + 1] = py;
+        v[i * 3 + 2] = pz;
+    }
+}
+
+/**
+ * Stand-in colliders and world poses for the subjects of rigid TransformedShape3D wrappers, one per
+ * level of nesting (a wrapper may wrap a wrapper, and both sides of a pair may be wrapped).
+ * @type {Array<{shape: AbstractShape3D|null, friction: number|undefined, restitution: number|undefined, flags: number|undefined}>}
+ */
+const subject_colliders = [];
+
+/** @type {Transform64[]} */
+const subject_poses = [];
+
+let subject_depth = 0;
+
+/**
+ * The subject pose of the current level of nesting, made on first use.
+ *
+ * @returns {Transform64}
+ */
+function subject_pose_here() {
+    const level = subject_depth;
+
+    if (level === subject_colliders.length) {
+        subject_colliders.push({ shape: null, friction: undefined, restitution: undefined, flags: undefined });
+        subject_poses.push(new Transform64());
+    }
+
+    return subject_poses[level];
+}
+
+/**
+ * Dispatch a pair one of whose shapes is a rigid {@link TransformedShape3D}, as its SUBJECT at the
+ * composed world pose, which {@link rigid_subject_pose} must just have written into this level's
+ * {@link subject_pose_here}.
+ *
+ * A rigid wrapper moves its subject without changing it, so the subject collides through whatever
+ * routine its own type has — a wrapped box is a box, with the box's closed forms and its four-point
+ * manifold. Left wrapped it had no routine: it fell to the GJK + EPA fallback, which put the contact at
+ * the bodies' origins. That is how the first-person player's capsule, lifted off the feet by a
+ * wrapper, met everything it touched.
+ *
+ * @param {number} count
+ * @param {Collider} colA
+ * @param {Transform64} trA
+ * @param {Collider} colB
+ * @param {Transform64} trB
+ * @param {boolean} a_side the wrapper is A's shape (else B's)
+ * @returns {number}
+ */
+function dispatch_subject(count, colA, trA, colB, trB, a_side) {
+    const level = subject_depth;
+
+    const wrapper_col = a_side ? colA : colB;
+
+    // the materials and the sensor flag belong to the collider, not the shape
+    const col = subject_colliders[level];
+    col.shape = wrapper_col.shape.subject;
+    col.friction = wrapper_col.friction;
+    col.restitution = wrapper_col.restitution;
+    col.flags = wrapper_col.flags;
+
+    const pose = subject_poses[level];
+
+    subject_depth++;
+
+    const result = a_side
+        ? dispatch_pair(count, col, pose, colB, trB)
+        : dispatch_pair(count, colA, trA, col, pose);
+
+    subject_depth--;
+
+    return result;
+}
+
 /**
  * Run pairwise narrowphase for one (colliderA, colliderB) tuple — dispatches
  * by shape type and appends 0..K contacts to the candidate buffer. Returns
@@ -485,6 +1980,23 @@ function dispatch_pair(count, colA, trA, colB, trB) {
     const shapeA = colA.shape;
     const shapeB = colB.shape;
 
+    // A rigid wrapper is its subject, moved: see dispatch_subject. (A scaling one is not, and stays.)
+    if (shapeA.isTransformedShape3D === true && rigid_subject_pose(
+        subject_pose_here(), shapeA,
+        trA.translation_x, trA.translation_y, trA.translation_z,
+        trA.rotation_x, trA.rotation_y, trA.rotation_z, trA.rotation_w
+    )) {
+        return dispatch_subject(count, colA, trA, colB, trB, true);
+    }
+
+    if (shapeB.isTransformedShape3D === true && rigid_subject_pose(
+        subject_pose_here(), shapeB,
+        trB.translation_x, trB.translation_y, trB.translation_z,
+        trB.rotation_x, trB.rotation_y, trB.rotation_z, trB.rotation_w
+    )) {
+        return dispatch_subject(count, colA, trA, colB, trB, false);
+    }
+
     // Per-contact materials: combine the two source colliders' coefficients
     // once here (this is the only place that knows the exact collider on each
     // side) and stamp them onto every contact this dispatch appends. The
@@ -528,85 +2040,54 @@ function dispatch_pair(count, colA, trA, colB, trB) {
 
     // sphere-sphere
     if (isSphereA && isSphereB) {
-        const ra = shapeA.radius, rb = shapeB.radius;
+        const a = pair_sphere_a, b = pair_sphere_b;
+        sphere_record_pack(a, trA, shapeA);
+        sphere_record_pack(b, trB, shapeB);
 
-        const ok = sphere_sphere_contact(
-            sphere_result,
-            trA.translation_x, trA.translation_y, trA.translation_z,
-            trB.translation_x, trB.translation_y, trB.translation_z,
-            ra, rb
-        );
+        const ok = sphere_sphere_contact_array(sphere_result, a, 0, b, 0);
 
         if (!ok) return count;
 
         const nx = sphere_result[0], ny = sphere_result[1], nz = sphere_result[2];
+        const ra = a[3], rb = b[3];
 
         // Sphere-sphere produces exactly one contact per pair; fid = 1
         // identifies it as a real feature (distinguishes from "no info" = 0)
         // and is trivially stable across frames. Witnesses are the surface
         // points along the (unit) normal, scaled by each sphere's radius.
-        return append_contact(count,
-            trA.translation_x - nx * ra, trA.translation_y - ny * ra, trA.translation_z - nz * ra,
-            trB.translation_x + nx * rb, trB.translation_y + ny * rb, trB.translation_z + nz * rb,
-            nx, ny, nz, sphere_result[3], 1);
+        const c = pair_contact;
+        c[0] = a[0] - nx * ra; c[1] = a[1] - ny * ra; c[2] = a[2] - nz * ra;
+        c[3] = b[0] + nx * rb; c[4] = b[1] + ny * rb; c[5] = b[2] + nz * rb;
+        c[6] = nx; c[7] = ny; c[8] = nz;
+        c[9] = sphere_result[3];
+        c[10] = 1;
+        return append_contact_record(count, c, 0);
     }
 
     // sphere ↔ box
     if ((isSphereA && isBoxB) || (isBoxA && isSphereB)) {
-        const sphereTr    = isSphereA ? trA : trB;
-        const sphereShape = isSphereA ? shapeA : shapeB;
-        const boxTr    = isSphereA ? trB : trA;
-        const boxShape = isSphereA ? shapeB : shapeA;
-        const bh = boxShape.half_extents;
-
-        const ok = sphere_box_contact(
-            closed_form_result,
-            sphereTr.translation_x, sphereTr.translation_y, sphereTr.translation_z, sphereShape.radius,
-            boxTr.translation_x, boxTr.translation_y, boxTr.translation_z,
-            boxTr.rotation_x, boxTr.rotation_y, boxTr.rotation_z, boxTr.rotation_w,
-            bh.x, bh.y, bh.z
-        );
+        sphere_record_pack(pair_sphere_a, isSphereA ? trA : trB, isSphereA ? shapeA : shapeB);
+        box_record_pack(pair_box_b, isSphereA ? trB : trA, (isSphereA ? shapeB : shapeA).half_extents);
 
-        if (!ok) return count;
+        const ok = sphere_box_contact_array(closed_form_result, pair_sphere_a, 0, pair_box_b, 0);
 
-        let nx = closed_form_result[0], ny = closed_form_result[1], nz = closed_form_result[2];
+        if (!ok) return count;
 
-        const depth = closed_form_result[3];
-        const wsx = closed_form_result[4], wsy = closed_form_result[5], wsz = closed_form_result[6];
-        const wbx = closed_form_result[7], wby = closed_form_result[8], wbz = closed_form_result[9];
         // Feature id from the box-local voronoi region (1..27) — stable
         // while the sphere stays on the same face / edge / vertex of the
         // box, which is the steady-state case for resting / sliding contact.
+        const fid = sphere_box_voronoi_fid_array(pair_sphere_a, 0, pair_box_b, 0);
 
-        const fid = sphere_box_voronoi_fid(
-            sphereTr.translation_x, sphereTr.translation_y, sphereTr.translation_z,
-            boxTr.translation_x, boxTr.translation_y, boxTr.translation_z,
-            boxTr.rotation_x, boxTr.rotation_y, boxTr.rotation_z, boxTr.rotation_w,
-            bh.x, bh.y, bh.z
-        );
-
-        if (isSphereA) {
-            return append_contact(count, wsx, wsy, wsz, wbx, wby, wbz, nx, ny, nz, depth, fid);
-        } else {
-            return append_contact(count, wbx, wby, wbz, wsx, wsy, wsz, -nx, -ny, -nz, depth, fid);
-        }
+        // normal box → sphere, [4..6] on the sphere, [7..9] on the box
+        return append_closed_form_contact(count, closed_form_result, isSphereA, fid);
     }
 
     // box-box multi-point
     if (isBoxA && isBoxB) {
-        const ah = shapeA.half_extents;
-        const bh = shapeB.half_extents;
-        const ok = box_box_manifold(
-            box_manifold_result,
-            trA.translation_x, trA.translation_y, trA.translation_z,
-            trA.rotation_x, trA.rotation_y, trA.rotation_z, trA.rotation_w,
-            ah.x, ah.y, ah.z,
-            trB.translation_x, trB.translation_y, trB.translation_z,
-            trB.rotation_x, trB.rotation_y, trB.rotation_z, trB.rotation_w,
-            bh.x, bh.y, bh.z
-        );
+        box_record_pack(pair_box_a, trA, shapeA.half_extents);
+        box_record_pack(pair_box_b, trB, shapeB.half_extents);
+        const ok = box_box_manifold_array(box_manifold_result, pair_box_a, 0, pair_box_b, 0);
         if (!ok) return count;
-        const nx = box_manifold_result[0], ny = box_manifold_result[1], nz = box_manifold_result[2];
         const cc = box_manifold_result[3] | 0;
         // Box-box manifolds: closed-form clipping doesn't expose stable
         // per-contact feature ids (a contact migrates from "incident-vertex k"
@@ -616,13 +2097,7 @@ function dispatch_pair(count, colA, trA, colB, trB) {
         // typically stay >>MATCH_TOL apart, so position matching is
         // unambiguous frame-to-frame.
         for (let k = 0; k < cc; k++) {
-            const base = 4 + k * 7;
-            count = append_contact(count,
-                box_manifold_result[base],     box_manifold_result[base + 1], box_manifold_result[base + 2],
-                box_manifold_result[base + 3], box_manifold_result[base + 4], box_manifold_result[base + 5],
-                nx, ny, nz,
-                box_manifold_result[base + 6],
-                0);
+            count = append_box_manifold_contact(count, box_manifold_result, 4 + k * 7);
         }
         return count;
     }
@@ -630,100 +2105,74 @@ function dispatch_pair(count, colA, trA, colB, trB) {
     // capsule-capsule (multi-point: near-parallel overlap emits both ends of
     // the overlap interval; everything else the single closest-point contact)
     if (isCapsuleA && isCapsuleB) {
-        const a_shape = colA.shape, b_shape = colB.shape;
-        const n_cc = capsule_capsule_multi_contacts(
-            capsule_capsule_result,
-            trA.translation_x, trA.translation_y, trA.translation_z,
-            trA.rotation_x, trA.rotation_y, trA.rotation_z, trA.rotation_w,
-            a_shape.radius, a_shape.height * 0.5,
-            trB.translation_x, trB.translation_y, trB.translation_z,
-            trB.rotation_x, trB.rotation_y, trB.rotation_z, trB.rotation_w,
-            b_shape.radius, b_shape.height * 0.5
-        );
+        capsule_record_pack(pair_capsule_a, trA, shapeA);
+        capsule_record_pack(pair_capsule_b, trB, shapeB);
+        const n_cc = capsule_capsule_multi_contacts_array(capsule_capsule_result, pair_capsule_a, 0, pair_capsule_b, 0);
         for (let k = 0; k < n_cc; k++) {
-            const off = k * CAPSULE_CAPSULE_CONTACT_STRIDE;
             // fid = k + 1: stable per interval end (1-based; 0 = no info).
-            count = append_contact(count,
-                capsule_capsule_result[off],     capsule_capsule_result[off + 1], capsule_capsule_result[off + 2],
-                capsule_capsule_result[off + 3], capsule_capsule_result[off + 4], capsule_capsule_result[off + 5],
-                capsule_capsule_result[off + 6], capsule_capsule_result[off + 7], capsule_capsule_result[off + 8],
-                capsule_capsule_result[off + 9], k + 1);
+            count = append_manifold_contact(count, capsule_capsule_result, k * CAPSULE_CAPSULE_CONTACT_STRIDE, true, k + 1);
         }
         return count;
     }
 
     // capsule ↔ sphere
     if ((isCapsuleA && isSphereB) || (isSphereA && isCapsuleB)) {
-        const capsuleTr = isCapsuleA ? trA : trB;
-        const capsuleShape = isCapsuleA ? colA.shape : colB.shape;
-        const sphereTr    = isCapsuleA ? trB : trA;
-        const sphereShape = isCapsuleA ? colB.shape : colA.shape;
-        const ok = capsule_sphere_contact(
-            closed_form_result,
-            capsuleTr.translation_x, capsuleTr.translation_y, capsuleTr.translation_z,
-            capsuleTr.rotation_x, capsuleTr.rotation_y, capsuleTr.rotation_z, capsuleTr.rotation_w,
-            capsuleShape.radius, capsuleShape.height * 0.5,
-            sphereTr.translation_x, sphereTr.translation_y, sphereTr.translation_z, sphereShape.radius
-        );
+        capsule_record_pack(pair_capsule_a, isCapsuleA ? trA : trB, isCapsuleA ? shapeA : shapeB);
+        sphere_record_pack(pair_sphere_b, isCapsuleA ? trB : trA, isCapsuleA ? shapeB : shapeA);
+        const ok = capsule_sphere_contact_array(closed_form_result, pair_capsule_a, 0, pair_sphere_b, 0);
         if (!ok) return count;
-        let nx = closed_form_result[0], ny = closed_form_result[1], nz = closed_form_result[2];
-        const depth = closed_form_result[3];
-        const cap_x = closed_form_result[4], cap_y = closed_form_result[5], cap_z = closed_form_result[6];
-        const sph_x = closed_form_result[7], sph_y = closed_form_result[8], sph_z = closed_form_result[9];
-        // Single contact per capsule-sphere pair; fid = 1.
-        if (isCapsuleA) {
-            return append_contact(count, cap_x, cap_y, cap_z, sph_x, sph_y, sph_z, nx, ny, nz, depth, 1);
-        } else {
-            return append_contact(count, sph_x, sph_y, sph_z, cap_x, cap_y, cap_z, -nx, -ny, -nz, depth, 1);
-        }
+        // normal sphere → capsule, [4..6] on the capsule, [7..9] on the sphere. Single contact per
+        // capsule-sphere pair; fid = 1.
+        return append_closed_form_contact(count, closed_form_result, isCapsuleA, 1);
     }
 
     // capsule ↔ box (multi-point — 1 closest-segment + up to 2 cap-centres)
     if ((isCapsuleA && isBoxB) || (isBoxA && isCapsuleB)) {
-        const capsuleTr = isCapsuleA ? trA : trB;
-        const capsuleShape = isCapsuleA ? shapeA : shapeB;
-        const boxTr       = isCapsuleA ? trB : trA;
-        const boxShape    = isCapsuleA ? shapeB : shapeA;
-        const bh = boxShape.half_extents;
-        const cc = capsule_box_multi_contacts(
-            capsule_box_multi_result,
-            capsuleTr.translation_x, capsuleTr.translation_y, capsuleTr.translation_z,
-            capsuleTr.rotation_x, capsuleTr.rotation_y, capsuleTr.rotation_z, capsuleTr.rotation_w,
-            capsuleShape.radius, capsuleShape.height * 0.5,
-            boxTr.translation_x, boxTr.translation_y, boxTr.translation_z,
-            boxTr.rotation_x, boxTr.rotation_y, boxTr.rotation_z, boxTr.rotation_w,
-            bh.x, bh.y, bh.z
-        );
+        capsule_record_pack(pair_capsule_a, isCapsuleA ? trA : trB, isCapsuleA ? shapeA : shapeB);
+        box_record_pack(pair_box_b, isCapsuleA ? trB : trA, (isCapsuleA ? shapeB : shapeA).half_extents);
+        const cc = capsule_box_multi_contacts_array(capsule_box_multi_result, pair_capsule_a, 0, pair_box_b, 0);
         if (cc === 0) return count;
         // multi_result layout per contact: cap_x/y/z (A side), box_x/y/z (B side), nx/ny/nz, depth.
         // Feature id per sub-contact: 1 = closest-segment, 2/3 = caps. The
         // emission order from capsule_box_multi_contacts is stable across
         // frames for the same geometric configuration.
         for (let k = 0; k < cc; k++) {
-            const o = k * CAPSULE_BOX_CONTACT_STRIDE;
-            const cap_x = capsule_box_multi_result[o];
-            const cap_y = capsule_box_multi_result[o + 1];
-            const cap_z = capsule_box_multi_result[o + 2];
-            const box_x = capsule_box_multi_result[o + 3];
-            const box_y = capsule_box_multi_result[o + 4];
-            const box_z = capsule_box_multi_result[o + 5];
-            const nx    = capsule_box_multi_result[o + 6];
-            const ny    = capsule_box_multi_result[o + 7];
-            const nz    = capsule_box_multi_result[o + 8];
-            const depth = capsule_box_multi_result[o + 9];
-            const sub_fid = k + 1;
-            if (isCapsuleA) {
-                count = append_contact(count, cap_x, cap_y, cap_z, box_x, box_y, box_z, nx, ny, nz, depth, sub_fid);
-            } else {
-                count = append_contact(count, box_x, box_y, box_z, cap_x, cap_y, cap_z, -nx, -ny, -nz, depth, sub_fid);
-            }
+            count = append_manifold_contact(count, capsule_box_multi_result, k * CAPSULE_BOX_CONTACT_STRIDE, isCapsuleA, k + 1);
         }
         return count;
     }
 
     // convex hull ↔ convex hull (multi-point clipping via GJK + EPA + face-clip).
     if (shapeA.isConvexHullShape3D === true && shapeB.isConvexHullShape3D === true) {
-        return hull_pair_contacts(count, shapeA, trA, shapeB, trB, append_contact);
+        return hull_pair_contacts(count, shapeA, trA, shapeB, trB);
+    }
+
+    // box ↔ convex hull: a box is a polytope too, so it takes the same axis and face clip — a
+    // face-on-face patch, not the generic fallback's single contact.
+    if (isBoxA && shapeB.isConvexHullShape3D === true) {
+        box_polytope_set(shapeA.half_extents);
+        return hull_pair_contacts(count, box_polytope, trA, shapeB, trB);
+    }
+
+    if (shapeA.isConvexHullShape3D === true && isBoxB) {
+        box_polytope_set(shapeB.half_extents);
+        return hull_pair_contacts(count, shapeA, trA, box_polytope, trB);
+    }
+
+    // convex hull ↔ sphere: closed form, the contact on the line through the sphere's centre
+    if ((shapeA.isConvexHullShape3D === true && isSphereB) || (isSphereA && shapeB.isConvexHullShape3D === true)) {
+        const hull_is_a = isSphereB;
+
+        pose_pack(pair_pose, hull_is_a ? trA : trB);
+        sphere_record_pack(pair_sphere_b, hull_is_a ? trB : trA, hull_is_a ? shapeB : shapeA);
+
+        const ok = hull_sphere_contact_array(closed_form_result, hull_is_a ? shapeA : shapeB, pair_pose, 0, pair_sphere_b, 0);
+
+        if (!ok) return count;
+
+        // normal from the hull toward the sphere; [4..6] on the sphere, [7..9] on the hull; one
+        // contact per pair, fid = 1
+        return append_closed_form_contact(count, closed_form_result, !hull_is_a, 1);
     }
 
     // mesh ↔ mesh. A globally-convex mesh collides as a single cached hull
@@ -735,7 +2184,7 @@ function dispatch_pair(count, colA, trA, colB, trB) {
         const hullA = get_mesh_convex_hull(shapeA);
         const hullB = get_mesh_convex_hull(shapeB);
         if (hullA !== null && hullB !== null) {
-            return hull_pair_contacts(count, hullA, trA, hullB, trB, append_contact);
+            return hull_pair_contacts(count, hullA, trA, hullB, trB);
         }
         return mesh_mesh_tet_contacts(count, shapeA, trA, shapeB, trB, append_contact);
     }
@@ -762,34 +2211,41 @@ function dispatch_pair(count, colA, trA, colB, trB) {
         const convex_col  = isConcaveA ? colB : colA;
         const convex_tr   = isConcaveA ? trB : trA;
 
+        // The two bodies' poses, packed once for the calls below and the per-triangle kernels: passed
+        // as numbers to a call that is not inlined, every one would be boxed (see
+        // triangle_vertices_to_world).
+        pose_pack(convex_pose, convex_tr);
+        pose_pack(concave_pose, concave_tr);
+
         // 1. Convex shape's world AABB.
         convex_col.shape.compute_bounding_box(concave_local_aabb);
-        aabb3_transform_oriented(
-            concave_world_aabb, 0,
-            concave_local_aabb[0], concave_local_aabb[1], concave_local_aabb[2],
-            concave_local_aabb[3], concave_local_aabb[4], concave_local_aabb[5],
-            convex_tr.translation_x, convex_tr.translation_y, convex_tr.translation_z,
-            convex_tr.rotation_x, convex_tr.rotation_y, convex_tr.rotation_z, convex_tr.rotation_w
-        );
+        aabb3_transform_oriented_array(concave_world_aabb, 0, concave_local_aabb, 0, convex_pose, 0);
 
         // 2. Project into concave's body-local frame.
-        aabb3_transform_oriented_inverse(
-            concave_query_aabb, 0,
-            concave_world_aabb,
-            concave_tr.translation_x, concave_tr.translation_y, concave_tr.translation_z,
-            concave_tr.rotation_x, concave_tr.rotation_y, concave_tr.rotation_z, concave_tr.rotation_w
-        );
+        aabb3_transform_oriented_inverse_array(concave_query_aabb, 0, concave_world_aabb, concave_pose, 0);
 
         // 3. Decompose concave shape into triangles overlapping the query.
-        //    The enumerator returns the TRUE overlap count — clamp to the
-        //    scratch capacity (overflow writes were dropped; reading past the
-        //    buffer would poison the manifold with NaN).
-        let tri_count = decompose_to_triangles(
-            triangle_buffer, 0, concave_col.shape,
-            concave_query_aabb[0], concave_query_aabb[1], concave_query_aabb[2],
-            concave_query_aabb[3], concave_query_aabb[4], concave_query_aabb[5]
-        );
-        if (tri_count > MAX_TRIANGLES_PER_PAIR) tri_count = MAX_TRIANGLES_PER_PAIR;
+        //    The enumerator returns the TRUE overlap count; when that did not
+        //    fit, grow and enumerate again (deterministic, so once suffices).
+        let tri_count = decompose_to_triangles_array(triangle_buffer, 0, concave_col.shape, concave_query_aabb, 0);
+        let tri_capacity = triangle_buffer.length / TRIANGLE_FLOAT_STRIDE;
+        if (tri_count > tri_capacity && tri_capacity < MAX_TRIANGLES_PER_PAIR) {
+            tri_capacity = Math.min(MAX_TRIANGLES_PER_PAIR, Math.max(tri_count, tri_capacity * 2));
+            triangle_buffer = new Float64Array(tri_capacity * TRIANGLE_FLOAT_STRIDE);
+            tri_count = decompose_to_triangles_array(triangle_buffer, 0, concave_col.shape, concave_query_aabb, 0);
+        }
+        if (tri_count > tri_capacity) {
+            // Past the bound: overflow writes were dropped, so never read them.
+            if (!triangle_overflow_reported) {
+                triangle_overflow_reported = true;
+                console.warn(
+                    `narrowphase: a ${convex_col.shape.constructor.name} overlaps ${tri_count} triangles of a`
+                    + ` ${concave_col.shape.constructor.name}; ${tri_capacity} are collided against and the`
+                    + ` rest are not. Coarsen the collision surface under it, or split the body.`
+                );
+            }
+            tri_count = tri_capacity;
+        }
         if (tri_count === 0) return count;
 
         // 4. Set up the convex side once; the concave side gets a
@@ -797,11 +2253,7 @@ function dispatch_pair(count, colA, trA, colB, trB) {
         //    the concave side as our internal "A" so EPA's sign-check
         //    convention matches the convex fallback below; the final
         //    append_contact() swaps if the original A was the convex one.
-        posed_b.setup_components(
-        convex_col.shape,
-        convex_tr.translation_x, convex_tr.translation_y, convex_tr.translation_z,
-        convex_tr.rotation_x, convex_tr.rotation_y, convex_tr.rotation_z, convex_tr.rotation_w
-    );
+        posed_b.setup_pose(convex_col.shape, convex_pose, 0);
         posed_a.shape = triangle_shape;
         posed_a.px = concave_tr.translation_x;
         posed_a.py = concave_tr.translation_y;
@@ -817,12 +2269,6 @@ function dispatch_pair(count, colA, trA, colB, trB) {
         const convex_wy = convex_tr.translation_y;
         const convex_wz = convex_tr.translation_z;
 
-        // Track the candidate-buffer index at the start of this
-        // concave dispatch — the per-triangle dedup pass scans from
-        // here to the current count, ignoring contacts from earlier
-        // collider pairs in the same body pair.
-        const pair_start_count = count;
-
         // Pre-compute concave's rotation components for the q · v · q⁻¹
         // rotations done per-triangle below (face normal + centroid).
         const cqx = concave_tr.rotation_x;
@@ -858,6 +2304,49 @@ function dispatch_pair(count, colA, trA, colB, trB) {
         const isCapsuleConvex = convex_col.shape.isCapsuleShape3D === true;
         const capsule_shape = isCapsuleConvex ? convex_col.shape : null;
 
+        if (isSphereConvex) {
+            convex_record[0] = convex_wx;
+            convex_record[1] = convex_wy;
+            convex_record[2] = convex_wz;
+            convex_record[3] = sphere_radius;
+        } else if (isBoxConvex || isCapsuleConvex) {
+            pose_pack(convex_record, convex_tr);
+
+            if (isBoxConvex) {
+                convex_record[7] = box_half_extents.x;
+                convex_record[8] = box_half_extents.y;
+                convex_record[9] = box_half_extents.z;
+            } else {
+                convex_record[7] = capsule_shape.radius;
+                convex_record[8] = capsule_shape.height * 0.5;
+            }
+        }
+
+        // The per-triangle dedup compares each new contact with the earlier
+        // contacts of THIS concave dispatch only — not those of earlier
+        // collider pairs in the same body pair — through an index that starts
+        // empty here (see dedup_contains). The sphere path matches on the
+        // normal alone, every other path on the normal and the A-side point.
+        dedup_begin(isSphereConvex);
+
+        // Contacts on an edge or a vertex of a triangle wait here until every triangle has been
+        // collided, then go through Box3D's internal-edge rules (see "Internal edges" above).
+        tentative_count = 0;
+        face_triangle_count = 0;
+
+        // where a round body touches a plane, for the contacts taken as a plane's
+        if (isSphereConvex) {
+            round_core[ROUND_RADIUS] = sphere_radius;
+            round_core[ROUND_HALF] = 0;
+            round_core_place(convex_tr);
+        } else if (isCapsuleConvex) {
+            round_core[ROUND_RADIUS] = capsule_shape.radius;
+            round_core[ROUND_HALF] = capsule_shape.height * 0.5;
+            round_core_place(convex_tr);
+        } else {
+            round_core[ROUND_RADIUS] = 0;
+        }
+
         for (let i = 0; i < tri_count; i++) {
             const tri_offset = i * TRIANGLE_FLOAT_STRIDE;
             triangle_shape.bind(triangle_buffer, tri_offset);
@@ -906,23 +2395,9 @@ function dispatch_pair(count, colA, trA, colB, trB) {
 
                 // Rotate each triangle vertex from concave-local to world
                 // via the shared helper.
-                triangle_vertices_to_world(
-                    scratch_tri_world,
-                    ax, ay, az, bx, by, bz, cx_v, cy_v, cz_v,
-                    cqx, cqy, cqz, cqw,
-                    c_pos_x, c_pos_y, c_pos_z
-                );
-                const ax_w = scratch_tri_world[0], ay_w = scratch_tri_world[1], az_w = scratch_tri_world[2];
-                const bx_w = scratch_tri_world[3], by_w = scratch_tri_world[4], bz_w = scratch_tri_world[5];
-                const cx_w = scratch_tri_world[6], cy_w = scratch_tri_world[7], cz_w = scratch_tri_world[8];
-
-                const ok = sphere_triangle_contact(
-                    sphere_triangle_result,
-                    convex_wx, convex_wy, convex_wz, sphere_radius,
-                    ax_w, ay_w, az_w,
-                    bx_w, by_w, bz_w,
-                    cx_w, cy_w, cz_w
-                );
+                triangle_vertices_to_world(scratch_tri_world, triangle_buffer, tri_offset, concave_pose);
+
+                const ok = sphere_triangle_contact_array(sphere_triangle_result, convex_record, 0, scratch_tri_world, 0);
 
                 if (!ok) continue;
 
@@ -939,7 +2414,8 @@ function dispatch_pair(count, colA, trA, colB, trB) {
                 // outward side of the triangle. If the contact normal
                 // opposes the face normal, the sphere is behind /
                 // inside the solid — skip rather than push it deeper.
-                if (n_t2s_x * fnx_w + n_t2s_y * fny_w + n_t2s_z * fnz_w <= 0) continue;
+                const n_dot_f = n_t2s_x * fnx_w + n_t2s_y * fny_w + n_t2s_z * fnz_w;
+                if (n_dot_f <= 0) continue;
 
                 // Stored normal convention is "B → A". `nx, ny, nz` here
                 // points convex → concave (which the existing EPA branch
@@ -953,44 +2429,48 @@ function dispatch_pair(count, colA, trA, colB, trB) {
                 const stored_nx_s = isConcaveA ? nx_s : -nx_s;
                 const stored_ny_s = isConcaveA ? ny_s : -ny_s;
                 const stored_nz_s = isConcaveA ? nz_s : -nz_s;
-                let is_duplicate_s = false;
-                for (let k = pair_start_count; k < count; k++) {
-                    const ko = k * CANDIDATE_STRIDE;
-                    const dnx = candidates[ko + 6] - stored_nx_s;
-                    const dny = candidates[ko + 7] - stored_ny_s;
-                    const dnz = candidates[ko + 8] - stored_nz_s;
-                    if (dnx * dnx + dny * dny + dnz * dnz < 0.001) {
-                        is_duplicate_s = true;
-                        break;
-                    }
-                }
-                if (is_duplicate_s) continue;
 
                 // Surface witnesses from the closed-form solver:
                 //   result[4..6] = sphere surface point (convex side)
                 //   result[7..9] = triangle closest point (concave side)
-                // Use the actual witnesses rather than body centres —
-                // unlike the EPA fallback (which uses body centres
-                // because flat-faced support witnesses can be arbitrarily
-                // far from the contact patch), closest-point-on-triangle
-                // is exact and lies on the contact patch.
+                // Closest-point-on-triangle is exact and lies on the
+                // contact patch.
                 const sphere_wx = sphere_triangle_result[4];
                 const sphere_wy = sphere_triangle_result[5];
                 const sphere_wz = sphere_triangle_result[6];
                 const tri_wx = sphere_triangle_result[7];
                 const tri_wy = sphere_triangle_result[8];
                 const tri_wz = sphere_triangle_result[9];
-                if (isConcaveA) {
-                    count = append_contact(count,
-                        tri_wx, tri_wy, tri_wz,
-                        sphere_wx, sphere_wy, sphere_wz,
-                        nx_s, ny_s, nz_s, sd, tri_fid);
-                } else {
-                    count = append_contact(count,
-                        sphere_wx, sphere_wy, sphere_wz,
-                        tri_wx, tri_wy, tri_wz,
-                        -nx_s, -ny_s, -nz_s, sd, tri_fid);
+
+                const c = staged_contact;
+                c[0] = isConcaveA ? tri_wx : sphere_wx;
+                c[1] = isConcaveA ? tri_wy : sphere_wy;
+                c[2] = isConcaveA ? tri_wz : sphere_wz;
+                c[3] = isConcaveA ? sphere_wx : tri_wx;
+                c[4] = isConcaveA ? sphere_wy : tri_wy;
+                c[5] = isConcaveA ? sphere_wz : tri_wz;
+                c[6] = stored_nx_s; c[7] = stored_ny_s; c[8] = stored_nz_s;
+                c[9] = sd;
+                c[10] = tri_fid;
+
+                // The nearest point on an edge or a vertex: it waits for the others, nearest first.
+                // (cos(n, face) < FACE_CONTACT_COS, squared: n is unit, n · face > 0.)
+                if (n_dot_f * n_dot_f < FACE_CONTACT_COS * FACE_CONTACT_COS * (fnx_w * fnx_w + fny_w * fny_w + fnz_w * fnz_w)) {
+                    const distance = sphere_radius - sd;
+
+                    c[11] = distance * distance;
+                    tentative_add(c, i, triangle_facing_feature(scratch_tri_world, sphere_triangle_result, 0));
+                    continue;
                 }
+
+                face_triangle_add(i);
+
+                // a duplicate is any earlier contact of this dispatch with the same normal (keyed by
+                // normal: the witness is not looked at)
+                if (dedup_contains(c, 0)) continue;
+
+                count = append_contact_record(count, c, 0);
+                dedup_insert(count - 1);
                 continue;
             }
 
@@ -998,25 +2478,9 @@ function dispatch_pair(count, colA, trA, colB, trB) {
             if (isBoxConvex) {
                 // Rotate each triangle vertex from concave-local to world
                 // via the shared helper.
-                triangle_vertices_to_world(
-                    scratch_tri_world,
-                    ax, ay, az, bx, by, bz, cx_v, cy_v, cz_v,
-                    cqx, cqy, cqz, cqw,
-                    c_pos_x, c_pos_y, c_pos_z
-                );
-                const ax_w = scratch_tri_world[0], ay_w = scratch_tri_world[1], az_w = scratch_tri_world[2];
-                const bx_w = scratch_tri_world[3], by_w = scratch_tri_world[4], bz_w = scratch_tri_world[5];
-                const cx_w = scratch_tri_world[6], cy_w = scratch_tri_world[7], cz_w = scratch_tri_world[8];
-
-                const ok = box_triangle_contact(
-                    box_triangle_result,
-                    convex_tr.translation_x, convex_tr.translation_y, convex_tr.translation_z,
-                    convex_tr.rotation_x, convex_tr.rotation_y, convex_tr.rotation_z, convex_tr.rotation_w,
-                    box_half_extents.x, box_half_extents.y, box_half_extents.z,
-                    ax_w, ay_w, az_w,
-                    bx_w, by_w, bz_w,
-                    cx_w, cy_w, cz_w
-                );
+                triangle_vertices_to_world(scratch_tri_world, triangle_buffer, tri_offset, concave_pose);
+
+                const ok = box_triangle_contact_array(box_triangle_result, convex_record, 0, scratch_tri_world, 0);
                 if (!ok) continue;
 
                 // Same convention as sphere_triangle: result normal points
@@ -1030,7 +2494,8 @@ function dispatch_pair(count, colA, trA, colB, trB) {
                 // One-sided rejection: the box must lie on the outward
                 // side of the triangle. If the contact normal opposes
                 // the face normal, the box is inside the solid → skip.
-                if (n_t2box_x * fnx_w + n_t2box_y * fny_w + n_t2box_z * fnz_w <= 0) continue;
+                const n_dot_f = n_t2box_x * fnx_w + n_t2box_y * fny_w + n_t2box_z * fnz_w;
+                if (n_dot_f <= 0) continue;
 
                 const nx_b = -n_t2box_x;
                 const ny_b = -n_t2box_y;
@@ -1039,11 +2504,23 @@ function dispatch_pair(count, colA, trA, colB, trB) {
                 const stored_ny_b = isConcaveA ? ny_b : -ny_b;
                 const stored_nz_b = isConcaveA ? nz_b : -nz_b;
 
+                const cc = box_triangle_result[3] | 0;
+
+                // A face contact: on the triangle's face, or on a face of the box lying within 60° of
+                // it. An edge-edge axis, or a box face standing up off the triangle, is tentative, and
+                // waits for the internal-edge rules.
+                const axis = box_triangle_result[BOX_TRIANGLE_AXIS_OFFSET];
+                let face = axis === BOX_TRIANGLE_AXIS_TRIANGLE_FACE;
+
+                if (axis === BOX_TRIANGLE_AXIS_BOX_FACE) {
+                    // cos(n, face) > HULL_FACE_COS, squared: n is unit, n · face > 0
+                    face = n_dot_f * n_dot_f > HULL_FACE_COS * HULL_FACE_COS * (fnx_w * fnx_w + fny_w * fny_w + fnz_w * fnz_w);
+                }
+
                 // Emit each clipped contact. The contact count from
                 // box_triangle_contact is at most 4; combined with the
                 // existing per-pair candidate cap (64 entries), tens of
                 // overlapping triangles per pair are safely accommodated.
-                const cc = box_triangle_result[3] | 0;
                 for (let k = 0; k < cc; k++) {
                     const base = 4 + k * 7;
                     const t_wx = box_triangle_result[base];
@@ -1056,45 +2533,32 @@ function dispatch_pair(count, colA, trA, colB, trB) {
 
                     // Dedup against earlier candidates in THIS dispatch
                     // (adjacent triangles can produce coincident contacts
-                    // — same as the sphere and EPA paths).
-                    let is_duplicate_k = false;
-                    for (let q = pair_start_count; q < count; q++) {
-                        const qo = q * CANDIDATE_STRIDE;
-                        const dnx = candidates[qo + 6] - stored_nx_b;
-                        const dny = candidates[qo + 7] - stored_ny_b;
-                        const dnz = candidates[qo + 8] - stored_nz_b;
-                        if (dnx * dnx + dny * dny + dnz * dnz < 0.001) {
-                            // Same normal; check positions too (a
-                            // multi-point manifold has distinct points
-                            // with the same normal — those should NOT
-                            // be deduped). Compare the world-A side
-                            // (triangle surface or box surface depending
-                            // on dispatcher swap).
-                            const pa_x = isConcaveA ? t_wx : b_wx;
-                            const pa_y = isConcaveA ? t_wy : b_wy;
-                            const pa_z = isConcaveA ? t_wz : b_wz;
-                            const dpx = candidates[qo]     - pa_x;
-                            const dpy = candidates[qo + 1] - pa_y;
-                            const dpz = candidates[qo + 2] - pa_z;
-                            if (dpx * dpx + dpy * dpy + dpz * dpz < 1e-6) {
-                                is_duplicate_k = true;
-                                break;
-                            }
-                        }
-                    }
-                    if (is_duplicate_k) continue;
-
-                    if (isConcaveA) {
-                        count = append_contact(count,
-                            t_wx, t_wy, t_wz,
-                            b_wx, b_wy, b_wz,
-                            nx_b, ny_b, nz_b, d_k, tri_fid);
-                    } else {
-                        count = append_contact(count,
-                            b_wx, b_wy, b_wz,
-                            t_wx, t_wy, t_wz,
-                            -nx_b, -ny_b, -nz_b, d_k, tri_fid);
+                    // — same as the sphere and EPA paths): same normal AND
+                    // same world-A point (triangle surface or box surface
+                    // depending on dispatcher swap) — a multi-point manifold
+                    // has distinct points with the same normal, and those
+                    // should NOT be deduped.
+                    const c = staged_contact;
+                    c[0] = isConcaveA ? t_wx : b_wx;
+                    c[1] = isConcaveA ? t_wy : b_wy;
+                    c[2] = isConcaveA ? t_wz : b_wz;
+                    c[3] = isConcaveA ? b_wx : t_wx;
+                    c[4] = isConcaveA ? b_wy : t_wy;
+                    c[5] = isConcaveA ? b_wz : t_wz;
+                    c[6] = stored_nx_b; c[7] = stored_ny_b; c[8] = stored_nz_b;
+                    c[9] = d_k;
+                    c[10] = tri_fid;
+
+                    if (!face) {
+                        c[11] = 0;
+                        tentative_add(c, i, triangle_witness_feature(scratch_tri_world, box_triangle_result, base));
+                        continue;
                     }
+
+                    if (dedup_contains(c, 0)) continue;
+
+                    count = append_contact_record(count, c, 0);
+                    dedup_insert(count - 1);
                 }
                 continue;
             }
@@ -1103,25 +2567,9 @@ function dispatch_pair(count, colA, trA, colB, trB) {
             if (isCapsuleConvex) {
                 // Rotate each triangle vertex from concave-local to world
                 // via the shared helper.
-                triangle_vertices_to_world(
-                    scratch_tri_world,
-                    ax, ay, az, bx, by, bz, cx_v, cy_v, cz_v,
-                    cqx, cqy, cqz, cqw,
-                    c_pos_x, c_pos_y, c_pos_z
-                );
-                const ax_w = scratch_tri_world[0], ay_w = scratch_tri_world[1], az_w = scratch_tri_world[2];
-                const bx_w = scratch_tri_world[3], by_w = scratch_tri_world[4], bz_w = scratch_tri_world[5];
-                const cx_w = scratch_tri_world[6], cy_w = scratch_tri_world[7], cz_w = scratch_tri_world[8];
-
-                const cap_cc = capsule_triangle_contact(
-                    capsule_triangle_result,
-                    convex_tr.translation_x, convex_tr.translation_y, convex_tr.translation_z,
-                    convex_tr.rotation_x, convex_tr.rotation_y, convex_tr.rotation_z, convex_tr.rotation_w,
-                    capsule_shape.radius, capsule_shape.height * 0.5,
-                    ax_w, ay_w, az_w,
-                    bx_w, by_w, bz_w,
-                    cx_w, cy_w, cz_w
-                );
+                triangle_vertices_to_world(scratch_tri_world, triangle_buffer, tri_offset, concave_pose);
+
+                const cap_cc = capsule_triangle_contact_array(capsule_triangle_result, convex_record, 0, scratch_tri_world, 0);
                 if (cap_cc === 0) continue;
 
                 // Each sub-contact's normal can be distinct (a flat
@@ -1144,7 +2592,8 @@ function dispatch_pair(count, colA, trA, colB, trB) {
 
                     // One-sided face-normal rejection: capsule must be
                     // on the outward side of the triangle.
-                    if (n_t2cap_x * fnx_w + n_t2cap_y * fny_w + n_t2cap_z * fnz_w <= 0) continue;
+                    const n_dot_f = n_t2cap_x * fnx_w + n_t2cap_y * fny_w + n_t2cap_z * fnz_w;
+                    if (n_dot_f <= 0) continue;
 
                     // Stored normal "convex → concave" = "capsule →
                     // triangle" = negated t2cap.
@@ -1155,39 +2604,31 @@ function dispatch_pair(count, colA, trA, colB, trB) {
                     const stored_ny_c = isConcaveA ? ny_c : -ny_c;
                     const stored_nz_c = isConcaveA ? nz_c : -nz_c;
 
-                    // Dedup against earlier candidates in THIS dispatch.
-                    let is_duplicate_c = false;
-                    for (let q = pair_start_count; q < count; q++) {
-                        const qo = q * CANDIDATE_STRIDE;
-                        const dnx = candidates[qo + 6] - stored_nx_c;
-                        const dny = candidates[qo + 7] - stored_ny_c;
-                        const dnz = candidates[qo + 8] - stored_nz_c;
-                        if (dnx * dnx + dny * dny + dnz * dnz < 0.001) {
-                            const pa_x = isConcaveA ? ct_x : cap_x;
-                            const pa_y = isConcaveA ? ct_y : cap_y;
-                            const pa_z = isConcaveA ? ct_z : cap_z;
-                            const dpx = candidates[qo]     - pa_x;
-                            const dpy = candidates[qo + 1] - pa_y;
-                            const dpz = candidates[qo + 2] - pa_z;
-                            if (dpx * dpx + dpy * dpy + dpz * dpz < 1e-6) {
-                                is_duplicate_c = true;
-                                break;
-                            }
-                        }
-                    }
-                    if (is_duplicate_c) continue;
-
-                    if (isConcaveA) {
-                        count = append_contact(count,
-                            ct_x, ct_y, ct_z,
-                            cap_x, cap_y, cap_z,
-                            nx_c, ny_c, nz_c, d_c, tri_fid);
-                    } else {
-                        count = append_contact(count,
-                            cap_x, cap_y, cap_z,
-                            ct_x, ct_y, ct_z,
-                            -nx_c, -ny_c, -nz_c, d_c, tri_fid);
+                    const c = staged_contact;
+                    c[0] = isConcaveA ? ct_x : cap_x;
+                    c[1] = isConcaveA ? ct_y : cap_y;
+                    c[2] = isConcaveA ? ct_z : cap_z;
+                    c[3] = isConcaveA ? cap_x : ct_x;
+                    c[4] = isConcaveA ? cap_y : ct_y;
+                    c[5] = isConcaveA ? cap_z : ct_z;
+                    c[6] = stored_nx_c; c[7] = stored_ny_c; c[8] = stored_nz_c;
+                    c[9] = d_c;
+                    c[10] = tri_fid;
+
+                    // Each sub-contact is a closest-point contact: on the face when its normal is the
+                    // face's; otherwise on an edge or a vertex, and it waits for the internal-edge rules.
+                    if (n_dot_f * n_dot_f < FACE_CONTACT_COS * FACE_CONTACT_COS * (fnx_w * fnx_w + fny_w * fny_w + fnz_w * fnz_w)) {
+                        c[11] = 0;
+                        tentative_add(c, i, triangle_witness_feature(scratch_tri_world, capsule_triangle_result, base + 3));
+                        continue;
                     }
+
+                    // Dedup against earlier candidates in THIS dispatch:
+                    // same normal AND same world-A point.
+                    if (dedup_contains(c, 0)) continue;
+
+                    count = append_contact_record(count, c, 0);
+                    dedup_insert(count - 1);
                 }
                 continue;
             }
@@ -1260,58 +2701,105 @@ function dispatch_pair(count, colA, trA, colB, trB) {
             const ny = -ey * inv;
             const nz = -ez * inv;
 
-            // Dedup against earlier contacts emitted in THIS dispatch.
-            // Adjacent triangles (heightmap cells sharing a diagonal;
-            // mesh triangles sharing an edge or vertex) often report
-            // identical contacts (same normal, same body-centre
-            // application points), and feeding duplicates to the
-            // sequential-impulse solver makes it escalate the impulse
-            // across iterations without bound. We deduplicate by
-            // contact normal within a small angular threshold: same
-            // body pair + same normal + same body-centre positions =
-            // the same physical contact, only one copy belongs in the
-            // manifold.
-            const stored_nx = isConcaveA ? nx : -nx;
-            const stored_ny = isConcaveA ? ny : -ny;
-            const stored_nz = isConcaveA ? nz : -nz;
-            let is_duplicate = false;
-            for (let k = pair_start_count; k < count; k++) {
-                const ko = k * CANDIDATE_STRIDE;
-                const dnx = candidates[ko + 6] - stored_nx;
-                const dny = candidates[ko + 7] - stored_ny;
-                const dnz = candidates[ko + 8] - stored_nz;
-                if (dnx * dnx + dny * dny + dnz * dnz < 0.001) {
-                    is_duplicate = true;
-                    break;
-                }
+            // Contact points: the triangle's supporting feature toward the convex body (the triangle
+            // itself, for a body lying on it) and the body's toward the triangle, clipped against each
+            // other — see support_feature_manifold. These used to be the two bodies' ORIGINS: under the
+            // contact only for a body directly above the concave body's origin, and a lever arm
+            // reaching across to it everywhere else. Internally the triangle is A and the convex body
+            // B, so (nx, ny, nz) — convex → triangle — is B → A.
+            triangle_vertices_to_world(scratch_tri_world, triangle_buffer, tri_offset, concave_pose);
+
+            const fn_inv = 1 / Math.sqrt(fnx_w * fnx_w + fny_w * fny_w + fnz_w * fnz_w);
+
+            triangle_feature(feature_a,
+                scratch_tri_world[0], scratch_tri_world[1], scratch_tri_world[2],
+                scratch_tri_world[3], scratch_tri_world[4], scratch_tri_world[5],
+                scratch_tri_world[6], scratch_tri_world[7], scratch_tri_world[8],
+                fnx_w * fn_inv, fny_w * fn_inv, fnz_w * fn_inv,
+                -nx, -ny, -nz
+            );
+            support_feature(feature_b, convex_col.shape,
+                convex_tr.translation_x, convex_tr.translation_y, convex_tr.translation_z,
+                convex_tr.rotation_x, convex_tr.rotation_y, convex_tr.rotation_z, convex_tr.rotation_w,
+                nx, ny, nz
+            );
+            feature_manifold(feature_manifold_result, feature_a, feature_b, nx, ny, nz, depth);
+
+            const mnx = feature_manifold_result[0];
+            const mny = feature_manifold_result[1];
+            const mnz = feature_manifold_result[2];
+            const stored_nx = isConcaveA ? mnx : -mnx;
+            const stored_ny = isConcaveA ? mny : -mny;
+            const stored_nz = isConcaveA ? mnz : -mnz;
+
+            const fc = feature_manifold_result[3];
+
+            // A face contact: the triangle's face facing the body — its polygon clipped, on its own
+            // normal — or a face of the body within 60° of the triangle's plane. Anything else is
+            // tentative, and waits for the internal-edge rules. The triangle's polygon on some other
+            // normal is not its face: feature_manifold falls back to the EPA axis when the clip of the
+            // two features finds nothing, and that axis off an edge of the triangle is a ghost.
+            // (mn is convex → triangle.)
+            let face = feature_a.kind === FEATURE_POLYGON
+                && -(mnx * fnx_w + mny * fny_w + mnz * fnz_w) * fn_inv >= FACE_CONTACT_COS;
+
+            if (!face && feature_b.kind === FEATURE_POLYGON) {
+                face = -(mnx * fnx_w + mny * fny_w + mnz * fnz_w) * fn_inv > HULL_FACE_COS;
             }
-            if (is_duplicate) continue;
-
-            // Contact application points: body centres rather than
-            // the triangle's centroid. The existing GJK+EPA fallback
-            // (below) uses the same convention — for vertical contacts
-            // (sphere/box on a flat surface, the common case), the
-            // lever arm r × n vanishes and the impulse resolves
-            // cleanly.
-            if (isConcaveA) {
-                count = append_contact(count,
-                    c_pos_x, c_pos_y, c_pos_z,
-                    convex_wx, convex_wy, convex_wz,
-                    nx, ny, nz, depth, tri_fid);
-            } else {
-                count = append_contact(count,
-                    convex_wx, convex_wy, convex_wz,
-                    c_pos_x, c_pos_y, c_pos_z,
-                    -nx, -ny, -nz, depth, tri_fid);
+
+            for (let k = 0; k < fc; k++) {
+                const base = 4 + k * 7;
+                // [base..+2] on the triangle, [base+3..+5] on the convex body
+                const t_wx = feature_manifold_result[base];
+                const t_wy = feature_manifold_result[base + 1];
+                const t_wz = feature_manifold_result[base + 2];
+                const c_wx = feature_manifold_result[base + 3];
+                const c_wy = feature_manifold_result[base + 4];
+                const c_wz = feature_manifold_result[base + 5];
+                const d_k = feature_manifold_result[base + 6];
+
+                // Dedup against earlier contacts in THIS dispatch: adjacent triangles report the
+                // same contact where they share an edge or a vertex, and duplicates make the
+                // sequential-impulse solver escalate. Same normal AND same point — a body resting
+                // across several coplanar triangles has distinct contacts sharing one normal.
+                const c = staged_contact;
+                c[0] = isConcaveA ? t_wx : c_wx;
+                c[1] = isConcaveA ? t_wy : c_wy;
+                c[2] = isConcaveA ? t_wz : c_wz;
+                c[3] = isConcaveA ? c_wx : t_wx;
+                c[4] = isConcaveA ? c_wy : t_wy;
+                c[5] = isConcaveA ? c_wz : t_wz;
+                c[6] = stored_nx; c[7] = stored_ny; c[8] = stored_nz;
+                c[9] = d_k;
+                c[10] = tri_fid;
+
+                if (!face) {
+                    c[11] = 0;
+                    tentative_add(c, i, triangle_witness_feature(scratch_tri_world, feature_manifold_result, base));
+                    continue;
+                }
+
+                if (dedup_contains(c, 0)) continue;
+
+                count = append_contact_record(count, c, 0);
+                dedup_insert(count - 1);
             }
         }
 
+        // The contacts on edges and vertices: kept where the surface has the edge; where it has none,
+        // dropped (a sphere's) or taken as contacts with the plane (anything else's).
+        if (tentative_count > 0) {
+            count = isSphereConvex
+                ? resolve_tentatives_by_claims(count, concave_col.shape, isConcaveA, concave_tr)
+                : resolve_tentatives_by_features(count, concave_col.shape, isConcaveA, concave_tr);
+        }
+
         return count;
     }
 
     // Robust GJK + EPA fallback for any convex pair without a closed form or a
-    // dedicated branch above (e.g. a primitive vs an authored ConvexHullShape3D,
-    // a cylinder/cone). gjk_epa_penetration returns the depth and writes a UNIT
+    // dedicated branch above (a cylinder against anything, a capsule against a
+    // hull, a scaling TransformedShape3D). gjk_epa_penetration returns the depth and writes a UNIT
     // axis into epa_result; we scale to the MTV vector (ex,ey,ez) the body-centre
     // sign-guard below consumes. Replaces the old gjk_with_axis +
     // expanding_polytope_algorithm pair, which returned a non-minimal axis on the
@@ -1383,31 +2871,38 @@ function dispatch_pair(count, colA, trA, colB, trB) {
     const inv = 1 / depth;
     const nx = -ex * inv, ny = -ey * inv, nz = -ez * inv; // stored normal, B → A
 
-    // Contact application points: body centres rather than support-function
-    // witnesses. The natural-sounding alternative — `posed_a.support(+EPA_dir)`
-    // and `posed_b.support(-EPA_dir)` — interacts badly with flat-faced
-    // supports: a large floor's support in `+Y` returns a *corner* (the box
-    // support is multi-valued along an axis-aligned direction and picks the
-    // sign-tied corner), which can be tens of metres from the actual
-    // contact patch. That blows up the solver's lever arm `r × n` and
-    // collapses `m_eff` to ~0, leaving the impulse vanishingly small.
-    //
-    // Body centres give `r ‖ n` for vertical contacts (sphere/knot landing
-    // on a floor — the common case), so `r × n = 0` and `m_eff = invM`
-    // resolves the impact cleanly. For oblique contacts the application
-    // point lies on the line between centres, which is the right-ish lever
-    // arm for translational impulse and degrades gracefully on angular
-    // response. A future closed-form mesh-vs-box path will compute a
-    // proper face-projected witness; until then, body centres are the
-    // robust fallback for the GJK+EPA route.
-    // GJK+EPA fallback has no stable per-frame feature info; emit fid = 0
-    // so match-and-merge uses position-fallback. Single contact per pair.
-    return append_contact(count,
+    // Contact points from the two supporting features along the axis (see support_feature_manifold):
+    // where the bodies actually touch. Raw support points will not do — a large flat side's support
+    // along its own normal is a tie between its corners, tens of metres from the patch — and the body
+    // origins this used to report are only under the contact directly above the other's origin;
+    // anywhere else the lever arm reached across to it and bodies with rotation enabled spun and fell
+    // through. No stable per-frame feature info: fid = 0, so match-and-merge matches by position.
+    support_feature(feature_a, colA.shape,
         trA.translation_x, trA.translation_y, trA.translation_z,
+        trA.rotation_x, trA.rotation_y, trA.rotation_z, trA.rotation_w,
+        -nx, -ny, -nz
+    );
+    support_feature(feature_b, colB.shape,
         trB.translation_x, trB.translation_y, trB.translation_z,
-        nx, ny, nz,
-        depth, 0
+        trB.rotation_x, trB.rotation_y, trB.rotation_z, trB.rotation_w,
+        nx, ny, nz
     );
+    feature_manifold(feature_manifold_result, feature_a, feature_b, nx, ny, nz, depth);
+
+    const mnx = feature_manifold_result[0], mny = feature_manifold_result[1], mnz = feature_manifold_result[2];
+    const cc = feature_manifold_result[3];
+
+    for (let k = 0; k < cc; k++) {
+        const base = 4 + k * 7;
+        count = append_contact(count,
+            feature_manifold_result[base], feature_manifold_result[base + 1], feature_manifold_result[base + 2],
+            feature_manifold_result[base + 3], feature_manifold_result[base + 4], feature_manifold_result[base + 5],
+            mnx, mny, mnz,
+            feature_manifold_result[base + 6], 0
+        );
+    }
+
+    return count;
 }
 
 // Reusable single-pair adapters for the penetration query below — no per-call
@@ -1446,8 +2941,9 @@ const _pp_trB = new Transform64();
  * step (depenetration, overlap depth, tooling) — never from inside one.
  *
  * Both poses are read BY INDEX on the way into the stand-in `Transform64`s —
- * a `Transform64`'s own `translation` / `rotation` (`Float64Array` views), a
- * `Vector3` / `Quaternion` (both `Float64Array` subclasses) and plain
+ * a retained `Float64Array` (not a Transform64's `translation` / `rotation`,
+ * which allocate a view per read), a `Vector3` / `Quaternion` (both
+ * `Float64Array` subclasses) and plain
  * `[x, y, z]` / `[x, y, z, w]` arrays all work; an `{x, y, z, w}` object does
  * not. Its components read as `undefined`, which trips `setTranslation`'s
  * `assert.isNumber` in development and, with `assert.*` stripped from a
@@ -1509,6 +3005,159 @@ export function deepest_pair_penetration(out_normal, shapeA, posA, rotA, shapeB,
     return best_depth;
 }
 
+/**
+ * Drop the sensor candidates among the first `count` when any solid candidate is there too,
+ * compacting the solids to the front in their enumeration order. Returns the surviving count.
+ *
+ * A body pair's collider cross-product feeds ONE candidate list, which the reduction cuts to
+ * {@link MAX_KEPT} by depth and spread, blind to the per-contact flags. A sensor overlaps the whole
+ * volume it covers, so its candidates are the deepest in the list and used to take every slot; the
+ * solver then skipped them for being sensors, and the solid contacts that should have held the body
+ * were never in the manifold. A cube on a thin pedestal wrapped by a trigger fell straight through it,
+ * and a crate carrying a 4 m pick-up zone fell through the floor.
+ *
+ * Sensor candidates are kept when the pair has nothing else, so `contact_count > 0` — the only thing
+ * the contact events key on (diff_manifolds) — is unchanged: the pair is in contact whenever any of
+ * its collider pairs is. Nothing that reaches gameplay says which collider pair a contact came from
+ * (the event is per body pair and its payload carries no flags), so a sensor overlap that coincides
+ * with a solid contact was never separately observable; the payload's representative contact is now
+ * the deepest SOLID one rather than the sensor's whole-volume depth.
+ *
+ * @param {number} count
+ * @returns {number}
+ */
+function drop_sensor_candidates_under_solids(count) {
+    let solids = 0;
+
+    for (let i = 0; i < count; i++) {
+        if ((candidates[i * CANDIDATE_STRIDE + 13] & CONTACT_FLAG_SENSOR) === 0) {
+            solids++;
+        }
+    }
+
+    if (solids === 0 || solids === count) {
+        return count;
+    }
+
+    let kept = 0;
+
+    for (let i = 0; i < count; i++) {
+        const src = i * CANDIDATE_STRIDE;
+
+        if ((candidates[src + 13] & CONTACT_FLAG_SENSOR) !== 0) {
+            continue;
+        }
+
+        if (kept !== i) {
+            candidates.copyWithin(kept * CANDIDATE_STRIDE, src, src + CANDIDATE_STRIDE);
+        }
+
+        kept++;
+    }
+
+    return kept;
+}
+
+/**
+ * World boxes of the colliders of the body pair in progress, six floats each: A's colliders, then B's.
+ *
+ * The broadphase pairs BODIES, so a body pair's every collider pair used to be dispatched: a static
+ * compound of 256 hulls under one ball dispatched 256 hull-sphere tests a step for the one child the
+ * ball sat on. A compound pair now tests each collider pair's boxes first, and dispatches only the pairs
+ * whose boxes touch.
+ *
+ * Exactly what the dispatch would have found: no routine makes a contact between separated shapes —
+ * every one needs them touching or overlapping (depth ≥ 0, no speculative margin) — and these are the
+ * boxes the broadphase builds its leaves from (compute_world_aabb, broadphase/compute_fat_world_aabb.js),
+ * at the very poses the dispatch reads. A collider whose box does not hold its surface (a height field
+ * whose sampler was written without bumping its version) is already missed by the broadphase alone; a
+ * compound inherits that, nothing more.
+ *
+ * Grown by doubling, high-water mark kept.
+ * @type {Float64Array}
+ */
+let collider_boxes = new Float64Array(16 * 6);
+
+/** A collider's box in its own frame, for {@link collider_box}. */
+const collider_local_box = new Float64Array(6);
+
+/**
+ * Slack on the box test, m: the boxes and the contact routines round differently, and a contact at
+ * depth 0 (touching) is still a contact. Neither needs more than this anywhere a body can be.
+ * @type {number}
+ */
+const COLLIDER_BOX_SLACK = 1e-6;
+
+/**
+ * Fill {@link collider_boxes} for a body pair's two collider lists.
+ *
+ * @param {Array<{collider: Collider, transform: Transform64}>} list_a
+ * @param {Array<{collider: Collider, transform: Transform64}>} list_b
+ */
+function compute_collider_boxes(list_a, list_b) {
+    const la_len = list_a.length;
+    const lb_len = list_b.length;
+
+    if ((la_len + lb_len) * 6 > collider_boxes.length) {
+        let length = collider_boxes.length * 2;
+
+        while (length < (la_len + lb_len) * 6) {
+            length *= 2;
+        }
+
+        collider_boxes = new Float64Array(length);
+    }
+
+    for (let a = 0; a < la_len; a++) {
+        collider_box(a, list_a[a]);
+    }
+
+    for (let b = 0; b < lb_len; b++) {
+        collider_box(la_len + b, list_b[b]);
+    }
+}
+
+/**
+ * Box `i` of {@link collider_boxes}: the collider's local box carried to its pose, compute_world_aabb's
+ * arithmetic read from the pose's components — that function takes the pose's translation and rotation
+ * views first, two allocations a call, which here would double the box's cost (76 ns against 35).
+ *
+ * @param {number} i
+ * @param {{collider: Collider, transform: Transform64}} entry
+ */
+function collider_box(i, entry) {
+    const t = entry.transform;
+
+    entry.collider.shape.compute_bounding_box(collider_local_box);
+
+    pose_pack(collider_pose, t);
+    aabb3_transform_oriented_array(collider_boxes, i * 6, collider_local_box, 0, collider_pose, 0);
+}
+
+/** The pose {@link collider_box} hands {@link aabb3_transform_oriented_array}. */
+const collider_pose = new Float64Array(7);
+
+/**
+ * Whether boxes `i` and `j` of {@link collider_boxes} are apart on some axis. A box with NaN in it is
+ * never apart: the dispatch decides what such a pair yields, as it did before the boxes were tested.
+ *
+ * @param {number} i
+ * @param {number} j
+ * @returns {boolean}
+ */
+function collider_boxes_apart(i, j) {
+    const b = collider_boxes;
+    const io = i * 6;
+    const jo = j * 6;
+
+    return b[io] > b[jo + 3] + COLLIDER_BOX_SLACK
+        || b[jo] > b[io + 3] + COLLIDER_BOX_SLACK
+        || b[io + 1] > b[jo + 4] + COLLIDER_BOX_SLACK
+        || b[jo + 1] > b[io + 4] + COLLIDER_BOX_SLACK
+        || b[io + 2] > b[jo + 5] + COLLIDER_BOX_SLACK
+        || b[jo + 2] > b[io + 5] + COLLIDER_BOX_SLACK;
+}
+
 /**
  * For every pair in `pair_list`, do a cross-product over A's collider list ×
  * B's collider list, accumulate candidate contacts, reduce to ≤4, and write
@@ -1550,11 +3199,23 @@ export function narrowphase_step(pair_list, manifolds, lists) {
         const la_len = list_a.length;
         const lb_len = list_b.length;
 
+        // A compound pair: the collider pairs whose boxes do not touch are not dispatched.
+        const pretest = la_len + lb_len > 2;
+
+        if (pretest) {
+            compute_collider_boxes(list_a, list_b);
+        }
+
         let sub_pair = 0;
         for (let a = 0; a < la_len; a++) {
             const ea = list_a[a];
 
-            for (let b = 0; b < lb_len; b++) {
+            for (let b = 0; b < lb_len; b++, sub_pair++) {
+                // Skipped pairs keep their number: it salts the fids below.
+                if (pretest && collider_boxes_apart(a, la_len + b)) {
+                    continue;
+                }
+
                 const eb = list_b[b];
 
                 const before = cand_count;
@@ -1576,7 +3237,6 @@ export function narrowphase_step(pair_list, manifolds, lists) {
                         if (candidates[co + 10] !== 0) candidates[co + 10] += salt;
                     }
                 }
-                sub_pair++;
             }
         }
 
@@ -1591,7 +3251,11 @@ export function narrowphase_step(pair_list, manifolds, lists) {
             continue;
         }
 
-        const kept = reduce_manifold_contacts(candidates, cand_count, CANDIDATE_STRIDE, MAX_KEPT, 9);
+        // Solids are reduced on their own; sensors only fill a manifold that has nothing solid.
+        cand_count = drop_sensor_candidates_under_solids(cand_count);
+
+        // Shared out between the planes the contacts lie on: see reduce_manifold_contacts_by_plane.
+        const kept = reduce_manifold_contacts_by_plane(candidates, cand_count, CANDIDATE_STRIDE, MAX_KEPT, 9, 6);
 
         // ── Match-and-merge: feature-id (with position fallback) ──────
         //
@@ -1679,16 +3343,7 @@ export function narrowphase_step(pair_list, manifolds, lists) {
             // copies the matched prev contact's impulses into THIS k,
             // so the geometric and warm-start state stay correlated
             // even if the matching mapping permuted the order.
-            manifolds.set_contact(
-                slot, k,
-                candidates[off],     candidates[off + 1], candidates[off + 2],
-                candidates[off + 3], candidates[off + 4], candidates[off + 5],
-                candidates[off + 6], candidates[off + 7], candidates[off + 8],
-                candidates[off + 9],
-                candidates[off + 10],
-                candidates[off + 11], candidates[off + 12],
-                candidates[off + 13]
-            );
+            manifolds.set_contact_from(slot, k, candidates, off);
             const prev_j = cand_to_prev[k];
             if (prev_j !== -1) {
                 // Copy prev_j's impulse to this slot index.
@@ -1723,9 +3378,9 @@ export function narrowphase_step(pair_list, manifolds, lists) {
  *
  * Matching is by feature id (stable per-triangle for the decomposition path),
  * so a contact's geometry tracks the same triangle across substeps. A contact
- * whose triangle isn't found this substep keeps its previous geometry (a rare
- * transient; the once-per-frame {@link narrowphase_step} re-establishes the
- * contact set next outer step). Count never changes here, so the solver's
+ * whose triangle isn't found this substep keeps its previous geometry, moved by
+ * how far the found contacts moved (a transient; the once-per-frame
+ * {@link narrowphase_step} re-establishes the contact set next outer step). Count never changes here, so the solver's
  * per-contact scratch (sized once at prepare) stays aligned.
  *
  * @param {ManifoldStore} manifolds
@@ -1742,11 +3397,22 @@ export function redetect_pair_geometry(manifolds, slot, list_a, list_b) {
     const count = manifolds.contact_count(slot);
     if (count === 0) return;
 
+    // As in narrowphase_step: a compound pair dispatches only the collider pairs whose boxes touch.
+    const pretest = la_len + lb_len > 2;
+
+    if (pretest) {
+        compute_collider_boxes(list_a, list_b);
+    }
+
     let cc = 0;
     let sub_pair = 0;
     for (let a = 0; a < la_len; a++) {
         const ea = list_a[a];
-        for (let b = 0; b < lb_len; b++) {
+        for (let b = 0; b < lb_len; b++, sub_pair++) {
+            if (pretest && collider_boxes_apart(a, la_len + b)) {
+                continue;
+            }
+
             const eb = list_b[b];
             const before = cc;
             cc = dispatch_pair(cc, ea.collider, ea.transform, eb.collider, eb.transform);
@@ -1760,7 +3426,6 @@ export function redetect_pair_geometry(manifolds, slot, list_a, list_b) {
                     if (candidates[co + 10] !== 0) candidates[co + 10] += salt;
                 }
             }
-            sub_pair++;
         }
     }
     if (cc === 0) return; // nothing re-detected this substep — keep frozen geometry
@@ -1782,6 +3447,10 @@ export function redetect_pair_geometry(manifolds, slot, list_a, list_b) {
     // single candidate exactly once — identical to the old behaviour.
     for (let k = 0; k < cc; k++) redetect_claimed[k] = 0;
 
+    // how far the matched contacts' points moved, summed, and the contacts left without a candidate
+    let moved_x = 0, moved_y = 0, moved_z = 0, moved = 0;
+    let stale = 0;
+
     for (let j = 0; j < count; j++) {
         const off = slot_off + j * CONTACT_STRIDE;
         const fid = data[off + 13];
@@ -1793,11 +3462,17 @@ export function redetect_pair_geometry(manifolds, slot, list_a, list_b) {
         const pay = data[off + 1];
         const paz = data[off + 2];
 
+        // A contact only takes geometry from a candidate of its own kind. The fresh candidates cover
+        // every collider pair, sensors included; a solid contact refreshed from a sensor's
+        // whole-volume overlap would keep its solid flag and push with the sensor's depth and normal.
+        const sensor = data[off + CONTACT_FLAGS_OFFSET] & CONTACT_FLAG_SENSOR;
+
         let best_k = -1;
         let best_d2 = Infinity;
         for (let k = 0; k < cc; k++) {
             if (redetect_claimed[k] === 1) continue;
             const co = k * CANDIDATE_STRIDE;
+            if ((candidates[co + 13] & CONTACT_FLAG_SENSOR) !== sensor) continue;
             if (candidates[co + 10] !== fid) continue;
             const dx = candidates[co]     - pax;
             const dy = candidates[co + 1] - pay;
@@ -1825,6 +3500,7 @@ export function redetect_pair_geometry(manifolds, slot, list_a, list_b) {
             for (let k = 0; k < cc; k++) {
                 if (redetect_claimed[k] === 1) continue;
                 const co = k * CANDIDATE_STRIDE;
+                if ((candidates[co + 13] & CONTACT_FLAG_SENSOR) !== sensor) continue;
                 const dx = candidates[co]     - pax;
                 const dy = candidates[co + 1] - pay;
                 const dz = candidates[co + 2] - paz;
@@ -1836,10 +3512,20 @@ export function redetect_pair_geometry(manifolds, slot, list_a, list_b) {
             }
         }
 
-        if (best_k === -1) continue; // no unclaimed candidate at all this substep — keep frozen geometry
+        if (best_k === -1) {
+            // no unclaimed candidate at all this substep: its geometry is kept, moved with the others
+            // (below)
+            if (stale < redetect_stale.length) redetect_stale[stale++] = off;
+            continue;
+        }
 
         redetect_claimed[best_k] = 1;
         const co = best_k * CANDIDATE_STRIDE;
+
+        moved_x += (candidates[co] + candidates[co + 3] - data[off] - data[off + 3]) * 0.5;
+        moved_y += (candidates[co + 1] + candidates[co + 4] - data[off + 1] - data[off + 4]) * 0.5;
+        moved_z += (candidates[co + 2] + candidates[co + 5] - data[off + 2] - data[off + 5]) * 0.5;
+        moved++;
         // Overwrite geometry only: witnesses, normal, depth. (Count, feature
         // ids and accumulated impulses are intentionally left untouched — see
         // the function contract.)
@@ -1854,4 +3540,20 @@ export function redetect_pair_geometry(manifolds, slot, list_a, list_b) {
         data[off + 8] = candidates[co + 8];
         data[off + 9] = candidates[co + 9];
     }
+
+    // A contact left without a candidate keeps its geometry from before this substep, and its points
+    // stay where they were while the body moves on: at 6 m/s, 25 mm behind it each substep. A capsule
+    // crossing a T-junction's rows lost one end's contact this way for a substep, and the frozen point,
+    // up to 100 mm behind its axis, spun it at 0.13 rad/s. Moved with the contacts that were found —
+    // by their mean displacement, the body's motion for one substep — it stays under the body.
+    if (stale > 0 && moved > 0) {
+        const dx = moved_x / moved, dy = moved_y / moved, dz = moved_z / moved;
+
+        for (let i = 0; i < stale; i++) {
+            const off = redetect_stale[i];
+
+            data[off] += dx; data[off + 1] += dy; data[off + 2] += dz;
+            data[off + 3] += dx; data[off + 4] += dy; data[off + 5] += dz;
+        }
+    }
 }