@woosh/meep-engine 3.37.0 → 3.39.0

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

@@ -1,52 +1,161 @@
 import { assert } from "../../../core/assert.js";
 import { bvh_query_user_data_intersects_aabb } from "../../../core/bvh2/bvh3/query/bvh_query_user_data_intersects_aabb.js";
 import { returnTrue } from "../../../core/function/returnTrue.js";
+import { lowbias32 } from "../../../core/math/hash/lowbias32.js";
 import { aabb3_transform_oriented } from "../../../core/geom/3d/aabb/aabb3_transform_oriented.js";
+import { aabb3_transform_oriented_inverse } from "../../../core/geom/3d/aabb/aabb3_transform_oriented_inverse.js";
 import { body_id_index } from "../body/BodyStorage.js";
 import { gjk } from "../../../core/geom/3d/gjk/gjk.js";
+import {
+    GJK_DISTANCE_RELATIVE_GAP,
+    gjk_distance,
+    gjk_simplex_translate_b,
+    GJKSimplex
+} from "../../../core/geom/3d/gjk/gjk_distance.js";
 import { mpr } from "../../../core/geom/3d/gjk/mpr.js";
 import { PosedShape3D } from "../../../core/geom/3d/shape/PosedShape3D.js";
+import { Triangle3D } from "../../../core/geom/3d/shape/Triangle3D.js";
+import { tri3_closest_point } from "../../../core/geom/3d/triangle/tri3_closest_point.js";
+import { v3_quaternion_apply } from "../../../core/geom/vec3/v3_quaternion_apply.js";
+import { v3_quaternion_apply_inverse } from "../../../core/geom/vec3/v3_quaternion_apply_inverse.js";
+import { TriangleEdgeFlags } from "../../../core/geom/3d/triangle/TriangleEdgeFlags.js";
+import { decompose_to_triangles } from "../narrowphase/decomposition/decompose_to_triangles.js";
+import { TRIANGLE_FEATURE_ID_OFFSET, TRIANGLE_FLOAT_STRIDE } from "../narrowphase/decomposition/triangle_buffer_layout.js";
+import { triangle_edge_flags } from "../narrowphase/decomposition/triangle_edge_flags.js";
+import { heightmap_box_triangles } from "../narrowphase/refine_ray_concave.js";
+import { rigid_subject_pose } from "../narrowphase/rigid_subject_pose.js";
+import { PENETRATION_SLOP } from "../solver/solve_contacts.js";
+import { Transform64 } from "../../ecs/transform/Transform64.js";
 
 /**
- * Bisection halts when the search interval is below this fraction of
- * the sweep length. With `MAX_BISECTION = 32` and a unit-length sweep
- * the achieved precision is ≈ 1 / 2³² (well below any practical
- * world-scale tolerance), but we cap on relative tolerance so a
- * 10 m sweep doesn't insist on sub-micron precision.
+ * The face shortcut's probe distance, and the bracket search's stopping width,
+ * as a fraction of the sweep length: precise enough for any practical sweep
+ * without a 10 m sweep insisting on sub-micron precision.
  * @type {number}
  */
 const TOI_TOLERANCE = 1e-4;
 
 /**
- * Maximum bisection iterations. `log2(1 / TOI_TOLERANCE)` is enough
- * for any practical sweep; this is the hard upper bound to prevent
+ * Maximum bisection iterations of the bracket search. `log2(1 / TOI_TOLERANCE)`
+ * is enough for any practical sweep; this is the hard upper bound to prevent
  * pathological inputs (NaN ray, etc.) from hanging the query.
  * @type {number}
  */
 const MAX_BISECTION = 32;
 
 /**
- * Coarse linear-search resolution for finding *any* overlap moment
- * along the per-candidate AABB-overlap interval (NOT the full sweep —
- * see `aabb_overlap_interval` for the analytical narrowing that runs
- * upstream). 32 substeps over the AABB-overlap window is dense enough
- * for any sweep where the shape's smallest extent is on the order of
- * its AABB's extent (true for spheres / boxes / capsules); the slab
- * intersection keeps that interval small even for kilometre-scale
- * sweeps, so this isn't the limit it would otherwise be.
+ * Samples of the bracket search's coarse scan for an overlapping moment. Only
+ * the fallback for an advancement that did not converge: 32 samples step clean
+ * over any feature thinner than 1/32 of the window they cover (a thin beam, a
+ * plank or a 1 mm box at an oblique pose — 186 of 300 crossings of a 2 cm beam
+ * at 45° were missed when this was the search).
  * @type {number}
  */
 const COARSE_STEPS = 32;
 
+/**
+ * The separation at which conservative advancement parks the swept shape short
+ * of a candidate: the reported pose is apart from it by at least this, and by
+ * no more than this plus {@link ADVANCE_TOLERANCE}. Box3D parks at its linear
+ * slop; this sits a tenth of {@link CONTACT_EPSILON} out, far under any skin a
+ * caller keeps — and, being apart, it is a pose the narrowphase (which reports
+ * only positive penetration) does not call a contact.
+ * @type {number}
+ */
+const ADVANCE_TARGET = 1e-5;
+
+/**
+ * How far past {@link ADVANCE_TARGET} the advancement may stop. Box3D's ratio,
+ * a quarter of the target.
+ * @type {number}
+ */
+const ADVANCE_TOLERANCE = 0.25 * ADVANCE_TARGET;
+
+/**
+ * How exactly the advancement asks the distance kernel for its gap on the way
+ * in. It steps by the gap's lower bound along that bound's normal, which is
+ * safe for any plane that separates the two, and a sweep that does not close
+ * on such a plane can never touch: neither needs the closest one. A bound this
+ * far under the truth shortens a step by no more than this, so the step still
+ * lands within {@link ADVANCE_TOLERANCE} of the target. What the touch is
+ * judged and reported by — its gap, its normal, whether the sweep still closes
+ * on it — is asked again at full precision once the bound is inside the touch
+ * band: a 2.5e-6 gap leaves a curved pair's normal up to half a degree off, and
+ * a body the sweep stopped at a corner kept up to 2 m/s of slide along it.
+ *
+ * The kernel's own stop, a 1e-10 relative gap, ran a sphere's queries 23
+ * iterations on average, a quarter to a third of them to its 32-iteration
+ * cap; asked this loosely on the way in, a sphere's casts at a mesh or a
+ * heightmap run in 0.63 to 0.76 of the time, a capsule's in 0.78 to 0.89.
+ * @type {number}
+ */
+const ADVANCE_DISTANCE_TOLERANCE = ADVANCE_TOLERANCE;
+
+/**
+ * Contacts that begin within this of each other along the sweep are one
+ * instant for ranking candidates, and a triangle FACE struck in that instant
+ * wins over anything else — another triangle's edge, a convex collider. A
+ * shape landing flat on a mesh face meets the seam to the face's other half at
+ * the very instant it meets the face, and the edge's contact, read off the
+ * closest points, carries its own normal: a box landing on a cube face read
+ * one 21° off it.
+ * @type {number}
+ */
+const SIMULTANEOUS = ADVANCE_TARGET;
+
+/**
+ * Most distance queries one candidate's advancement runs before it is taken
+ * as not converging and handed to the bracket search. A flat approach closes
+ * in one step and a curved one in a few; a near-graze converges linearly, the
+ * gap quartering per step, and takes about ten from metres away.
+ * @type {number}
+ */
+const ADVANCE_MAX_ITERATIONS = 32;
+
 const swept_aabb = new Float64Array(6);
 const local_aabb = new Float64Array(6);
 const initial_aabb = new Float64Array(6);
 const target_local_aabb = new Float64Array(6);
 const target_world_aabb = new Float64Array(6);
 
-// GJK simplex buffer (used to detect overlap during the bisection).
+// GJK simplex buffer (used to detect overlap at a sample pose).
 const simplex_buf = new Float64Array(12);
 
+/**
+ * The distance kernel's simplex and result, for conservative advancement. The
+ * simplex is carried from one advancement step to the next (the swept shape
+ * only translates between them), so each query starts where the last ended.
+ */
+const distance_simplex = new GJKSimplex();
+const distance_result = new Float64Array(10);
+
+/**
+ * The contact normal of the last {@link cast_candidate} hit found by
+ * advancement — the separating direction from the candidate to the swept shape
+ * at the reported pose — and whether there is one ({@link cast_has_normal}).
+ */
+const cast_normal = new Float64Array(3);
+let cast_has_normal = false;
+
+/**
+ * When the contact of the last {@link cast_candidate} hit actually begins, as
+ * near as it is known: a face's opening exactly, advancement's stop plus the
+ * gap it stopped short by over the closing speed, otherwise the reported time
+ * itself. Candidates are ranked by it rather than by the time they report: an
+ * advancement parks {@link ADVANCE_TARGET} short of its contact, so ranked by
+ * report it beat a face struck at the same instant — a sphere landing on a mesh
+ * face a millimetre from the seam took the neighbour's seam edge, 1.1° off.
+ * @type {number}
+ */
+let cast_touch_t = 0;
+
+/**
+ * Whether an advancement that ran out of iterations has been reported (once
+ * per process).
+ * @type {boolean}
+ */
+let advance_exhaustion_reported = false;
+
 // Scratch for MPR's MTV output — same vec3 convention as EPA: direction
 // is "A's interior into B" with the magnitude being the depth. We use
 // MPR for the contact-normal recovery at the kiss point because it
@@ -57,7 +166,7 @@ const mpr_result = new Float64Array(3);
 /**
  * Long-lived PosedShape3D adapters for the swept shape and the
  * candidate's collider. Both are re-bound per query — the swept one
- * also gets its position field re-written every bisection step
+ * also gets its position field re-written at every sample pose
  * without re-running `setup()`, since shape and rotation are
  * constant through the sweep.
  */
@@ -71,6 +180,290 @@ const candidate_posed = new PosedShape3D();
  */
 let scratch_candidates = new Uint32Array(64);
 
+/**
+ * "Already tested in this query" stamps, indexed by body index. Every collider
+ * of a body owns a separate broadphase leaf carrying that body's id, so a
+ * compound body arrives in {@link scratch_candidates} once per overlapping
+ * collider, and each arrival tests all of its colliders: a sweep along a row
+ * of K children ran K² collider casts (64 children: 4,096 casts, 0.54 ms).
+ * Stamped rather than cleared so the cost stays O(1) per query; the same
+ * scheme as `overlap_shape`'s.
+ * @type {Int32Array}
+ */
+let scratch_seen = new Int32Array(64);
+
+/**
+ * Stamp written into {@link scratch_seen} by the query in progress. Starts
+ * at 1 so a freshly zeroed (or freshly grown) slot never reads as seen.
+ * @type {number}
+ */
+let seen_stamp = 0;
+
+/**
+ * Whether a {@link shape_cast} is in progress. Its candidates, the triangles
+ * under it and every pose it tests are module state, so a cast started from
+ * inside one — from its filter — would overwrite the outer's half-finished
+ * scan (it reported no hit at all).
+ *
+ * The refusal is an assert, and a consumer's production build strips asserts:
+ * there nothing refuses it, and the outer cast misses without a word. A contact
+ * filter that runs a shapeCast is the case that bites: the CCD sweep asks it
+ * from inside its own cast, and with asserts stripped 200 of 200 fast spheres
+ * fired at a 2 cm wall went through it.
+ * @type {boolean}
+ */
+let shape_cast_running = false;
+
+const NESTED_SHAPE_CAST = 'shape_cast: called from inside a shape_cast, from its filter. A cast keeps its working'
+    + ' state in module scratch, so it cannot run inside another; a raycast or an overlap can. A contact filter'
+    + ' (PhysicsSystem.setContactFilter) is one such filter: the CCD sweep asks it from inside its cast.';
+
+/**
+ * Most triangles of one concave collider a sweep is tested against at once: the
+ * bound on {@link triangle_buffer}'s growth, the same 65,536 as the narrowphase,
+ * `compute_penetration`, `overlap_shape` and the ray's `refine_ray_concave`.
+ * A sweep whose box takes in more is walked a piece at a time, as the ray's is,
+ * each piece short enough for its box to fit; only a piece too short to split
+ * further — a pile of triangles in one spot — is tested against the first
+ * 65,536, and that is reported once. Unbounded, the scratch grew with the
+ * sweep's box, 80 bytes a triangle: a 140 m cast across a 100 m floor of 320,000
+ * triangles kept 25.6 MB of them.
+ * @type {number}
+ */
+const MAX_TRIANGLES_PER_PAIR = 1 << 16;
+
+/**
+ * Shortest piece of a sweep worth splitting further, as a fraction of it — the
+ * ray's `MIN_PIECE_FRACTION`.
+ * @type {number}
+ */
+const MIN_PIECE_FRACTION = 1 / (1 << 20);
+
+/**
+ * Whether a piece too short to split has overflowed (once per process).
+ * @type {boolean}
+ */
+let triangle_overflow_reported = false;
+
+/** The swept box of one piece of the sweep. */
+const piece_aabb = new Float64Array(6);
+
+/**
+ * A concave target's triangles that may overlap the swept AABB, in the target's
+ * local frame, laid out as {@link decompose_to_triangles} writes them. Grows by
+ * doubling when a sweep covers more triangles than it holds — a dropped triangle
+ * is a hole in the surface, and the sweep would pass straight through it — up
+ * to {@link MAX_TRIANGLES_PER_PAIR}; the high-water mark is kept.
+ * @type {Float64Array}
+ */
+let triangle_buffer = new Float64Array(256 * TRIANGLE_FLOAT_STRIDE);
+
+/** The swept AABB re-expressed in a concave target's local frame. */
+const concave_query_aabb = new Float64Array(6);
+
+/**
+ * The world pose of the mesh or heightmap a rigid TransformedShape3D collider wraps: the collider's
+ * pose composed with the wrapper's ({@link rigid_subject_pose}). And its copy for the winner, which
+ * the next wrapped collider would otherwise move.
+ */
+const subject_pose = new Transform64();
+const best_subject_pose = new Transform64();
+
+/**
+ * The triangle under test, in its collider's local frame, and that collider's
+ * transform. `candidate_is_triangle` says whether `candidate_posed` is posing
+ * it (rather than a convex collider).
+ */
+const triangle_local = new Float64Array(9);
+/** @type {Transform64|null} */
+let triangle_tr = null;
+let candidate_is_triangle = false;
+
+/** The nearest triangle hit so far, kept for the normal probe after the scan. */
+const best_triangle_local = new Float64Array(9);
+
+/**
+ * {@link triangle_local} relative to an ANCHOR point on the triangle, and the
+ * flyweight shape bound to it; `candidate_posed` poses it at the anchor.
+ *
+ * Anchoring is what lets the convex machinery below run on a triangle. GJK
+ * does not care where a shape's origin is, but MPR takes the posed shape's
+ * position as a point INSIDE it (its V0) and reports the depth along the ray
+ * from V0 through the origin — and the normal probes close on that position.
+ * A mesh's own origin can be metres off any one triangle, so the anchor must
+ * be ON the triangle: its centroid while sweeping, and for a normal probe the
+ * point of the triangle nearest the probed shape, which aims MPR's ray down
+ * the contact normal. The centroid would not do there: from a contact near the
+ * triangle's edge — the seam between two triangles of one flat face — the ray
+ * to it leaves through the edge, and MPR reports a normal tilted ~16° off the
+ * face it struck.
+ */
+const triangle_vertices = new Float64Array(9);
+const triangle_shape = new Triangle3D().bind(triangle_vertices, 0);
+
+/** Scratch: a point in a collider's frame, and the same point in world space. */
+const anchor_local = new Float64Array(3);
+const anchor_world = new Float64Array(3);
+
+/**
+ * The part of the sweep that can touch the triangle under test, written by
+ * {@link load_triangle}; empty (`enter > exit`) when the sweep does not close
+ * on its plane.
+ */
+let triangle_window_enter = Infinity;
+let triangle_window_exit = -Infinity;
+
+/**
+ * How far the swept shape reaches across the plane of the triangle under test
+ * as the sweep starts, when the sweep closes on that plane; written by
+ * {@link load_triangle}.
+ * @type {number}
+ */
+let triangle_start_depth = Infinity;
+
+/**
+ * When the swept shape's centre passes through the triangle under test — its
+ * plane, within its edges — or `Infinity` when it does not; written by
+ * {@link load_triangle}.
+ * @type {number}
+ */
+let triangle_centre_crossing = Infinity;
+
+/**
+ * Whether the triangle under test is one the sweep does NOT close on, so that
+ * its edges may still be met ({@link triangle_edges_to_sweep}); written by
+ * {@link load_triangle}, with what that needs: the concave shape it came from,
+ * the plane's unit normal in that shape's frame facing the sweep's start, and
+ * the nearest the sweep's origin comes to the plane.
+ * @type {boolean}
+ */
+let triangle_edges_pending = false;
+/** @type {AbstractShape3D|null} */
+let triangle_edge_shape = null;
+const triangle_plane_local = new Float64Array(3);
+let triangle_edge_nearest = 0;
+
+/**
+ * One edge of the triangle under test, as a segment — a triangle whose last two
+ * vertices coincide — relative to the edge's midpoint, where `candidate_posed`
+ * poses it.
+ */
+const edge_vertices = new Float64Array(9);
+const edge_shape = new Triangle3D().bind(edge_vertices, 0);
+
+/**
+ * Where the triangle under test sits in {@link triangle_buffer}, and how many
+ * triangles of its collider the buffer holds — for the search for its
+ * neighbours in {@link triangle_edges_to_sweep}.
+ */
+let triangle_offset = 0;
+let triangle_count = 0;
+
+/** Scratch: the contact normal of the best edge hit so far. */
+const edge_normal = new Float64Array(3);
+
+/**
+ * The point of the swept shape that reaches the plane of the triangle under
+ * test first — its support toward the plane — at the sweep's origin; written by
+ * {@link load_triangle} when the sweep closes on the plane.
+ */
+const triangle_touch_origin = new Float64Array(3);
+
+/**
+ * Whether the swept shape, reaching the plane of the triangle under test at
+ * `t` (its window's opening), reaches it on the triangle: whether the point
+ * that touches the plane first ({@link triangle_touch_origin}, carried along
+ * the sweep to `t`) lies within the triangle's edges. A point on an edge
+ * counts — the seam of a face split in two belongs to both halves.
+ *
+ * @param {number} dx unit sweep direction
+ * @param {number} dy
+ * @param {number} dz
+ * @param {number} t
+ * @returns {boolean}
+ */
+function triangle_touch_inside(dx, dy, dz, t) {
+    const tr = triangle_tr;
+    v3_quaternion_apply_inverse(
+        anchor_local, 0,
+        triangle_touch_origin[0] + dx * t - tr.translation_x,
+        triangle_touch_origin[1] + dy * t - tr.translation_y,
+        triangle_touch_origin[2] + dz * t - tr.translation_z,
+        tr.rotation_x, tr.rotation_y, tr.rotation_z, tr.rotation_w
+    );
+    const px = anchor_local[0], py = anchor_local[1], pz = anchor_local[2];
+    const v = triangle_local;
+
+    const e1x = v[3] - v[0], e1y = v[4] - v[1], e1z = v[5] - v[2];
+    const e2x = v[6] - v[0], e2y = v[7] - v[1], e2z = v[8] - v[2];
+    const nx = e1y * e2z - e1z * e2y;
+    const ny = e1z * e2x - e1x * e2z;
+    const nz = e1x * e2y - e1y * e2x;
+
+    // the point is on the inner side of every edge: (edge × to-point) · normal ≥ 0
+    for (let k = 0; k < 3; k++) {
+        const a = 3 * k, b = 3 * ((k + 1) % 3);
+        const ex = v[b] - v[a], ey = v[b + 1] - v[a + 1], ez = v[b + 2] - v[a + 2];
+        const qx = px - v[a], qy = py - v[a + 1], qz = pz - v[a + 2];
+        const cx = ey * qz - ez * qy;
+        const cy = ez * qx - ex * qz;
+        const cz = ex * qy - ey * qx;
+        if (cx * nx + cy * ny + cz * nz < 0) return false;
+    }
+    return true;
+}
+
+/**
+ * The world normal of the triangle under test, facing the sweep's start —
+ * written by {@link load_triangle} when the sweep closes on it — and a support
+ * point scratch.
+ */
+const plane_normal = new Float64Array(3);
+const support_point = new Float64Array(3);
+
+/** The reversed {@link plane_normal}, the direction the swept shape's near support is asked along. */
+const plane_normal_reversed = new Float64Array(3);
+
+/** The sweep's origin [0..2] and unit direction [3..5] in a concave collider's frame. */
+const local_sweep = new Float64Array(6);
+
+/**
+ * Whether the last {@link cast_candidate} hit was a triangle FACE contact —
+ * the shape met the triangle where it first reached its plane — whose normal
+ * is the face's.
+ * @type {boolean}
+ */
+let cast_face = false;
+
+/**
+ * The contact normal the nearest hit so far came with, when it came with one:
+ * a triangle face's, or the separating direction advancement stopped on.
+ */
+const best_normal = new Float64Array(3);
+
+/**
+ * What the last successful {@link shape_cast} struck, in world space: the
+ * convex collider, or the triangle of a concave one (its vertices kept here,
+ * the collider's frame). Read through {@link shape_cast_struck_support}.
+ */
+const struck_posed = new PosedShape3D();
+const struck_triangle_vertices = new Float64Array(9);
+const struck_triangle_shape = new Triangle3D().bind(struck_triangle_vertices, 0);
+
+/**
+ * {@link cast_candidate}: the sweep does not reach this candidate before the
+ * limit, or steps over it.
+ * @type {number}
+ */
+const CAST_MISS = -1;
+
+/**
+ * {@link cast_candidate}: the shape starts inside this candidate and cannot
+ * move at all.
+ * @type {number}
+ */
+const CAST_BLOCKED = -2;
+
 /**
  * Depths at or below this are not a contact. A kissing pair is not always
  * numerically exact — MPR returns a few microns of "overlap" for a sphere
@@ -107,10 +500,65 @@ const NORMAL_PROBE_OFFSET = 0.01;
  */
 const probe_normal = new Float64Array(3);
 
+/**
+ * Pose {@link triangle_local} as `candidate_posed`, anchored at the point
+ * `(lx, ly, lz)` of the triangle (in its collider's frame) — see
+ * {@link triangle_vertices}.
+ *
+ * @param {number} lx
+ * @param {number} ly
+ * @param {number} lz
+ */
+function anchor_triangle(lx, ly, lz) {
+    for (let i = 0; i < 9; i += 3) {
+        triangle_vertices[i] = triangle_local[i] - lx;
+        triangle_vertices[i + 1] = triangle_local[i + 1] - ly;
+        triangle_vertices[i + 2] = triangle_local[i + 2] - lz;
+    }
+
+    const tr = triangle_tr;
+    const qx = tr.rotation_x, qy = tr.rotation_y, qz = tr.rotation_z, qw = tr.rotation_w;
+    v3_quaternion_apply(anchor_world, 0, lx, ly, lz, qx, qy, qz, qw);
+    candidate_posed.setup_components(
+        triangle_shape,
+        tr.translation_x + anchor_world[0],
+        tr.translation_y + anchor_world[1],
+        tr.translation_z + anchor_world[2],
+        qx, qy, qz, qw
+    );
+}
+
+/**
+ * Anchor the triangle under test at its point nearest the world point
+ * `(px, py, pz)`.
+ *
+ * @param {number} px
+ * @param {number} py
+ * @param {number} pz
+ */
+function anchor_triangle_nearest(px, py, pz) {
+    const tr = triangle_tr;
+    v3_quaternion_apply_inverse(
+        anchor_local, 0,
+        px - tr.translation_x, py - tr.translation_y, pz - tr.translation_z,
+        tr.rotation_x, tr.rotation_y, tr.rotation_z, tr.rotation_w
+    );
+    const v = triangle_local;
+    tri3_closest_point(
+        anchor_local, 0,
+        anchor_local[0], anchor_local[1], anchor_local[2],
+        v[0], v[1], v[2],
+        v[3], v[4], v[5],
+        v[6], v[7], v[8]
+    );
+    anchor_triangle(anchor_local[0], anchor_local[1], anchor_local[2]);
+}
+
 /**
  * Recover the target's outward surface normal by running MPR on
  * `swept_posed` displaced to `(px, py, pz)` against `candidate_posed`
- * (both must already be bound by the caller).
+ * (both must already be bound by the caller). A triangle target is first
+ * re-anchored at its point nearest the probe pose.
  *
  * Returns `false` — leaving `out` untouched — when MPR reports no depth worth
  * the name (at or below {@link CONTACT_EPSILON}). That is not an MPR failure
@@ -120,33 +568,34 @@ const probe_normal = new Float64Array(3);
  * not an overlap".
  *
  * Sign-validation: MPR's polytope can settle on either side of the origin
- * for highly symmetric configurations, so we dot against the body-centre
- * axis and flip if needed (same pattern as `narrowphase_step`'s EPA path).
- * The stored normal is the target's outward surface normal — `B → A`
- * direction — i.e. the negated (validated) MTV.
+ * for highly symmetric configurations, so we dot against the axis to the
+ * target's centre (`candidate_posed`'s position) and flip if needed (same
+ * pattern as `narrowphase_step`'s EPA path). The stored normal is the
+ * target's outward surface normal — `B → A` direction — i.e. the negated
+ * (validated) MTV.
  *
  * @param {Float64Array} out receives the unit normal on success
  * @param {number} px swept shape's probe centre
  * @param {number} py
  * @param {number} pz
- * @param {Transform64} target_tr the target body's transform (centre for the
- *   sign check)
  * @returns {boolean}
  */
-function probe_contact_normal(out, px, py, pz, target_tr) {
+function probe_contact_normal(out, px, py, pz) {
     swept_posed.px = px;
     swept_posed.py = py;
     swept_posed.pz = pz;
 
+    if (candidate_is_triangle) anchor_triangle_nearest(px, py, pz);
+
     if (!mpr(mpr_result, 0, swept_posed, candidate_posed)) return false;
 
     let ex = mpr_result[0], ey = mpr_result[1], ez = mpr_result[2];
     const depth = Math.sqrt(ex * ex + ey * ey + ez * ez);
     if (!(depth > CONTACT_EPSILON) || !Number.isFinite(depth)) return false;
 
-    const ab_x = target_tr.translation_x - px;
-    const ab_y = target_tr.translation_y - py;
-    const ab_z = target_tr.translation_z - pz;
+    const ab_x = candidate_posed.px - px;
+    const ab_y = candidate_posed.py - py;
+    const ab_z = candidate_posed.pz - pz;
     if (ex * ab_x + ey * ab_y + ez * ab_z < 0) {
         ex = -ex; ey = -ey; ez = -ez;
     }
@@ -180,8 +629,9 @@ function probe_contact_normal(out, px, py, pz, target_tr) {
  * probe 1 separates them further. Either way MPR reports zero depth, and zero
  * depth carries no direction.
  *
- * So probe 2 displaces toward the target's CENTRE, which is interior to it
- * (MPR's own precondition) and so closes on it from any contact orientation.
+ * So probe 2 displaces toward the target's CENTRE — a convex collider's
+ * origin, or a triangle's point nearest the contact pose — which is interior to
+ * it (MPR's own precondition) and so closes on it from any contact orientation.
  * It starts from the CONTACT pose rather than probe 1's — anchoring it at
  * probe 1's pose lets a sweep directly away from the surface cancel the two
  * displacements against each other and land back on the tangency it was trying
@@ -211,21 +661,24 @@ function probe_contact_normal(out, px, py, pz, target_tr) {
  * @param {number} dx unit sweep direction
  * @param {number} dy
  * @param {number} dz
- * @param {Transform64} target_tr the target body's transform
  * @returns {boolean} false when every probe degenerates — `out` is untouched
  */
-function recover_contact_normal(out, cx, cy, cz, dx, dy, dz, target_tr) {
+function recover_contact_normal(out, cx, cy, cz, dx, dy, dz) {
     if (probe_contact_normal(
         out,
         cx + dx * NORMAL_PROBE_OFFSET,
         cy + dy * NORMAL_PROBE_OFFSET,
         cz + dz * NORMAL_PROBE_OFFSET,
-        target_tr,
     )) return true;
 
-    const ab_x = target_tr.translation_x - cx;
-    const ab_y = target_tr.translation_y - cy;
-    const ab_z = target_tr.translation_z - cz;
+    // A triangle's centre for this purpose is its point nearest the contact
+    // pose: straight down the contact normal for a face, which is what the
+    // probe should close along.
+    if (candidate_is_triangle) anchor_triangle_nearest(cx, cy, cz);
+
+    const ab_x = candidate_posed.px - cx;
+    const ab_y = candidate_posed.py - cy;
+    const ab_z = candidate_posed.pz - cz;
     const ab_len = Math.sqrt(ab_x * ab_x + ab_y * ab_y + ab_z * ab_z);
     // Coincident centres leave no direction to close along, and the shapes are
     // then as overlapped as they get — probe 1 already had its answer. The
@@ -237,11 +690,1228 @@ function recover_contact_normal(out, cx, cy, cz, dx, dy, dz, target_tr) {
     // in log2(ab_len / NORMAL_PROBE_OFFSET) steps. Stopping there keeps the
     // probe on the near side of the target's centre.
     for (let d = NORMAL_PROBE_OFFSET; d < ab_len; d *= 2) {
-        if (probe_contact_normal(out, cx + ux * d, cy + uy * d, cz + uz * d, target_tr)) return true;
+        if (probe_contact_normal(out, cx + ux * d, cy + uy * d, cz + uz * d)) return true;
+    }
+    return false;
+}
+
+/**
+ * Time of impact of `swept_posed` — swept from `(ox, oy, oz)` along unit
+ * `(dx, dy, dz)` — against the one convex `candidate_posed`, searched on
+ * `[0, t_limit)`. Both must already be bound by the caller (shape and
+ * rotation for the swept one; shape and full pose for the candidate), and
+ * `swept_aabb` / `initial_aabb` must hold this sweep's bounds.
+ *
+ * A convex collider is one candidate; a concave one is as many candidates as
+ * it has triangles under the sweep, each run through here on its own, so
+ * every rule below — the initial-overlap semantics included — holds per
+ * triangle exactly as it holds per collider.
+ *
+ * @param {number} ox
+ * @param {number} oy
+ * @param {number} oz
+ * @param {number} dx
+ * @param {number} dy
+ * @param {number} dz
+ * @param {number} t_limit only an impact strictly before this is wanted
+ * @param {number} stop_width the face shortcut's probe distance, and the
+ *   bracket search's resolution
+ * @param {boolean} skip_initial_overlaps see {@link shape_cast}
+ * @param {number} window_enter the sweep can first touch the candidate no
+ *   earlier than this (`-Infinity` when nothing narrower than its AABB is
+ *   known)…
+ * @param {number} window_exit …and no later than this; an empty window
+ *   (`enter > exit`) means the candidate is only tested for overlap at the
+ *   start, and never swept. A finite window is a triangle's PLANE window (see
+ *   {@link load_triangle}), and opens the face shortcut below.
+ * @returns {number} the time of impact (a pose still apart from the
+ *   candidate), {@link CAST_MISS}, or {@link CAST_BLOCKED}; {@link cast_face}
+ *   says whether it was a face contact, and {@link cast_has_normal} whether
+ *   {@link cast_normal} holds its contact normal
+ */
+function cast_candidate(ox, oy, oz, dx, dy, dz, t_limit, stop_width, skip_initial_overlaps, window_enter, window_exit) {
+    cast_face = false;
+    cast_has_normal = false;
+
+    const empty_window = !(window_enter <= window_exit);
+    // a triangle whose face is not swept may still have edges that are
+    const edges_pending = empty_window && candidate_is_triangle && triangle_edges_pending;
+
+    // Under CCD semantics a candidate that is never swept is a miss whether it
+    // overlaps the start (skipped) or not — all there is to ask of a triangle
+    // not closed on is whether the shape meets one of its edges, the cheapest
+    // tests first (most triangles have none to sweep: a floor's are all flat).
+    // Whether the shape starts in the triangle is asked only of an edge it
+    // would otherwise hit (see `cast_triangle_edges`).
+    if (empty_window && skip_initial_overlaps) {
+        const edges = edges_pending ? triangle_edges_to_sweep(ox, oy, oz, skip_initial_overlaps) : 0;
+        return edges !== 0
+            ? cast_triangle_edges(ox, oy, oz, dx, dy, dz, t_limit, stop_width, skip_initial_overlaps, edges)
+            : CAST_MISS;
+    }
+
+    // The candidate's tight world AABB. A candidate whose AABB misses the
+    // whole swept volume can neither overlap the shape at the start nor be
+    // reached along the sweep — the cheap answer for most of a concave
+    // target's triangles, which are enumerated without a height filter.
+    candidate_posed.shape.compute_bounding_box(target_local_aabb);
+    aabb3_transform_oriented(
+        target_world_aabb, 0,
+        target_local_aabb[0], target_local_aabb[1], target_local_aabb[2],
+        target_local_aabb[3], target_local_aabb[4], target_local_aabb[5],
+        candidate_posed.px, candidate_posed.py, candidate_posed.pz,
+        candidate_posed.qx, candidate_posed.qy, candidate_posed.qz, candidate_posed.qw
+    );
+    if (target_world_aabb[0] > swept_aabb[3] || target_world_aabb[3] < swept_aabb[0]
+        || target_world_aabb[1] > swept_aabb[4] || target_world_aabb[4] < swept_aabb[1]
+        || target_world_aabb[2] > swept_aabb[5] || target_world_aabb[5] < swept_aabb[2]) {
+        return CAST_MISS;
+    }
+
+    // Already overlapping at t = 0? There is no time of impact to search
+    // for: the shapes never come into contact, they start in it. Under CCD
+    // semantics it is a resting contact to step over — skip THIS candidate
+    // only, and keep scanning for real blockers.
+    //
+    // Under kinematic semantics targets are SOLID: a shape that starts
+    // genuinely inside one is blocked where it stands, `t = 0`, whatever
+    // direction it is trying to sweep. Nothing can beat that, so stop
+    // scanning. Getting out is depenetration's job, not the sweep's.
+    //
+    // Exact TANGENCY is the exception, and it needs one. A zero-depth
+    // touch is not "inside" anything — the shape is resting against a
+    // face, or flush with a brush seam, and is free to slide along it or
+    // leave. It also survives depenetration, which has no depth to push
+    // out of, so it persists frame after frame.
+    //
+    // Reporting it as a `t = 0` hit ends the scan, and that is the whole
+    // problem: the caller is handed a contact it correctly judges harmless
+    // for this direction and concludes the sweep is clear, while the body
+    // it was actually about to hit was never tested. A character flush
+    // against a wall falls through the floor that way. So a tangency
+    // blocks only when the sweep drives INTO it, and otherwise steps aside
+    // and lets the scan continue.
+    //
+    // MPR's depth at the START pose is what separates the two: positive
+    // means genuine overlap, none means tangency. Tangency is also exactly
+    // where the normal is hardest to recover, hence the second probe; if
+    // even that degenerates there is no normal to judge with and the
+    // contact blocks, stopping short being the safe failure.
+    //
+    // A triangle whose plane the shape has not reached yet (its window opens
+    // after t = 0) cannot overlap it at the start, and needs no test.
+    //
+    // Under CCD semantics two triangles a body starts in are not skipped. One
+    // its centre goes through — the plane, within the edges — is a tunnel
+    // however deep the body starts, and blocks it where it stands, with the
+    // face's normal. One it rests on, in by no more than the solver's slop,
+    // that the sweep closes on by more than the slop (its window is open) is
+    // judged as a kinematic tangency is: only a sweep driving into it is
+    // stopped. Skipped, a 0.4 m box left on a mesh plate by a clamp and pushed
+    // down at 100 m/s went through it in one step.
+    swept_posed.px = ox; swept_posed.py = oy; swept_posed.pz = oz;
+    if (!(window_enter > 0 && !empty_window) && gjk(simplex_buf, swept_posed, candidate_posed)) {
+        if (skip_initial_overlaps) {
+            if (candidate_is_triangle && !empty_window && triangle_centre_crossing < t_limit) {
+                cast_face = true;
+                cast_touch_t = 0;
+                return CAST_BLOCKED;
+            }
+            if (!(candidate_is_triangle && !empty_window && triangle_start_depth <= PENETRATION_SLOP)) {
+                return CAST_MISS;
+            }
+        }
+
+        if (!probe_contact_normal(probe_normal, ox, oy, oz)) {
+            const known = recover_contact_normal(probe_normal, ox, oy, oz, dx, dy, dz);
+            if (known) {
+                // Both vectors are unit, so this is the sine of the angle
+                // between the sweep and the contact plane. Zero means
+                // exactly parallel — sliding along the face — and positive
+                // means leaving it; neither blocks. The tolerance matters
+                // because the parallel case sits right on the sign change,
+                // and an MPR-recovered normal carries ~1e-6 of angular
+                // noise: without it a sweep ALONG a face flips to
+                // "head-on" on solver noise alone.
+                const into = dx * probe_normal[0] + dy * probe_normal[1] + dz * probe_normal[2];
+                if (into > -GRAZING_SINE_EPSILON) return CAST_MISS;
+            }
+        }
+
+        cast_touch_t = 0;
+        return CAST_BLOCKED;
+    }
+
+    if (empty_window) {
+        // Not closed on: only an edge is left to meet.
+        const edges = edges_pending ? triangle_edges_to_sweep(ox, oy, oz, skip_initial_overlaps) : 0;
+        return edges !== 0
+            ? cast_triangle_edges(ox, oy, oz, dx, dy, dz, t_limit, stop_width, skip_initial_overlaps, edges)
+            : CAST_MISS;
+    }
+
+    // ── Slab intersection: narrow the search interval analytically ─
+    //
+    // Intersect the candidate's tight world AABB with the swept shape's
+    // AABB sliding along the sweep direction. The result is the t-interval
+    // `[t_aabb_enter, t_aabb_exit]` during which the two AABBs overlap.
+    // Outside this interval the actual shapes can't overlap either (AABB is
+    // a superset of the shape), so we get to skip all of [0, t_aabb_enter)
+    // and (t_aabb_exit, t_limit] without testing.
+    //
+    // This is the key to making `shapeCast` scale to long sweeps:
+    // a 1 km cast of a 1 m sphere against another 1 m sphere has an
+    // AABB-overlap window of ≈ 2 m (the sum of diameters along the
+    // sweep axis), reducing the coarse-step grid from a 30 m
+    // resolution (1000/32) to 6 cm (2/32).
+    let t_aabb_enter = -Infinity;
+    let t_aabb_exit = Infinity;
+    for (let ax = 0; ax < 3; ax++) {
+        const init_min = initial_aabb[ax];
+        const init_max = initial_aabb[ax + 3];
+        const body_min = target_world_aabb[ax];
+        const body_max = target_world_aabb[ax + 3];
+        const d_ax = ax === 0 ? dx : (ax === 1 ? dy : dz);
+        if (d_ax === 0) {
+            // Static along this axis: AABBs must overlap in their
+            // initial position or this candidate is unreachable.
+            if (init_max < body_min || init_min > body_max) return CAST_MISS;
+            continue;
+        }
+        // swept_min(t) = init_min + d·t, swept_max(t) = init_max + d·t.
+        // Slab-enter: swept_max(t) = body_min  →  t = (body_min − init_max) / d
+        // Slab-exit:  swept_min(t) = body_max  →  t = (body_max − init_min) / d
+        const t1 = (body_min - init_max) / d_ax;
+        const t2 = (body_max - init_min) / d_ax;
+        const lo = t1 < t2 ? t1 : t2;
+        const hi = t1 < t2 ? t2 : t1;
+        if (lo > t_aabb_enter) t_aabb_enter = lo;
+        if (hi < t_aabb_exit)  t_aabb_exit  = hi;
+    }
+    if (window_enter > t_aabb_enter) t_aabb_enter = window_enter;
+    if (window_exit < t_aabb_exit) t_aabb_exit = window_exit;
+    if (t_aabb_enter > t_aabb_exit) return CAST_MISS;
+
+    // Clamp to the relevant t-window: [0, t_limit]. Anything beyond it
+    // can't tighten the answer.
+    let t_start = t_aabb_enter > 0       ? t_aabb_enter : 0;
+    const t_end = t_aabb_exit  < t_limit ? t_aabb_exit  : t_limit;
+    if (t_start >= t_end) return CAST_MISS;
+
+    // ── Face contact: answered in closed form ──────────────────────
+    //
+    // A triangle's window opens the moment the shape reaches its plane, so
+    // nothing can touch the triangle sooner — and the point of the shape that
+    // reaches the plane first is known: its support toward the plane. If that
+    // point lands on the triangle, the shape met the triangle THERE, on its
+    // face: the time of impact is the window's opening, exact, and the contact
+    // normal is the face's (see `shape_cast`). A support and three cross
+    // products instead of an advancement, for every triangle under a body
+    // landing on a mesh floor. Otherwise the contact, if any, is with an edge
+    // or a corner, later. (The AABB slab can open a rounding error after the
+    // plane window does — that is the same instant.)
+    //
+    // This used to ask instead whether the shape overlapped the triangle a
+    // bisection tolerance, 1e-4 of the sweep, past the opening. A sphere's
+    // section through the plane by then reaches sideways by the square root
+    // of that depth times its diameter, so one reaching the plane just beyond
+    // the triangle's edge was taken to have struck the face, and reported the
+    // face's normal for the edge's: a 0.5 m sphere 0.15 m past a mesh cube's
+    // edge read 17.5° off on a 500 m cast.
+    if (window_enter >= 0 && t_start - window_enter <= stop_width) {
+        if (triangle_touch_inside(dx, dy, dz, window_enter)) {
+            cast_face = true;
+            cast_touch_t = t_start;
+            return t_start;
+        }
+    }
+
+    // Advance from a little short of the window: where the window opens on the
+    // AABB slab of an axis-aligned face, the shapes touch EXACTLY there, and an
+    // exact touch has no separating normal to advance along.
+    const t_from = t_start - 2 * ADVANCE_TARGET;
+    return advance_to_contact(ox, oy, oz, dx, dy, dz, t_from > 0 ? t_from : 0, t_end, stop_width);
+}
+
+/**
+ * The edges of the triangle under test — bit `k` for edge `k`, vertex `k` to
+ * vertex `k + 1` — that a sweep NOT closing on its plane (see
+ * {@link triangle_edges_pending}) is run against: none of the face, which it
+ * cannot enter, and of the edges, only those it can meet edge-on.
+ *
+ * It meets an edge from beyond it, so its motion has to carry it back across
+ * the edge's line, against the edge's outward direction in the plane; the
+ * edges it runs along or away from are behind it.
+ *
+ * It meets one at all only by already reaching across the plane — by more than
+ * {@link CONTACT_EPSILON} at the nearest the sweep comes to it. Not closing,
+ * it never reaches further, so a shape that does not straddle the plane cannot
+ * meet the triangle, and one merely touching it can only graze it. Under CCD
+ * semantics it has to reach across by more than {@link PENETRATION_SLOP} as
+ * well, as a plane closed on by no more than the slop is not swept either (see
+ * {@link load_triangle}): a body resting in a floor reaches across it by just
+ * that much, and an edge it meets only with that much of itself is the
+ * solver's to resolve, not something to tunnel through. Swept, every edge the
+ * flags and the neighbour search cannot see as interior — a T-junction, tiles
+ * a micrometre out of level — stopped a ball rolling across it, every step it
+ * crossed.
+ *
+ * And only at the surface's own boundary: the rim of an open surface, or an
+ * edge three faces share. Every other edge lies between exactly two faces, and
+ * is met on one of them first. A FLAT edge lies inside the flat stretch the two
+ * make, whose own boundary the shape crosses first. A CONCAVE one has its
+ * neighbour rising toward the shape, a plane the sweep closes on, and that
+ * face's sweep covers the edge. A shape coming at a convex ridge from outside
+ * approaches along a normal between the two faces', so it closes on at least
+ * one of their planes too, and that face finds the ridge. What is left of a
+ * ridge for a sweep closing on neither face is a shape already lying across
+ * one of them — a CCD body resting the solver's slop deep in it, a mover flush
+ * on it — brushing the ridge with the part of it already in, or on, the
+ * surface: the touch it started with, carried along, not something in its way.
+ * Swept anyway, where a face meets the ridge a hair after the edge, the edge
+ * wins and hands back its slanted normal in place of the face's: a capsule
+ * walking edge-on into a 2 mm mesh slab read a normal 0.16° off the end face's,
+ * slid along it, and walked off round the slab.
+ *
+ * The edge flags cannot tell a rim from a ridge, so the boundary is found by
+ * looking for the neighbour: the other triangles under the sweep sharing both
+ * of an edge's vertices, bit for bit (both enumerators write a shared vertex
+ * identically). A mesh's flags are kept and cost a lookup, so they go first and
+ * spare a floor — all flat edges — the search, which walks an index of the
+ * buffer's edges. A heightmap's neighbours are its grid's, so it needs no search
+ * ({@link heightmap_unshared_edges}): its edges all have neighbours but at its
+ * border.
+ *
+ * @param {number} ox sweep origin
+ * @param {number} oy
+ * @param {number} oz
+ * @param {boolean} skip_initial_overlaps see {@link shape_cast}
+ * @returns {number}
+ */
+function triangle_edges_to_sweep(ox, oy, oz, skip_initial_overlaps) {
+    const v = triangle_local;
+    const ldx = local_sweep[3], ldy = local_sweep[4], ldz = local_sweep[5];
+
+    // the triangle's normal, either way up: the edges' outward directions follow its winding
+    const e1x = v[3] - v[0], e1y = v[4] - v[1], e1z = v[5] - v[2];
+    const e2x = v[6] - v[0], e2y = v[7] - v[1], e2z = v[8] - v[2];
+    const nx = e1y * e2z - e1z * e2y;
+    const ny = e1z * e2x - e1x * e2z;
+    const nz = e1x * e2y - e1y * e2x;
+
+    let edges = 0;
+    for (let k = 0; k < 3; k++) {
+        const a = 3 * k, b = 3 * ((k + 1) % 3);
+        const ex = v[b] - v[a], ey = v[b + 1] - v[a + 1], ez = v[b + 2] - v[a + 2];
+        // edge × normal points out of the triangle across the edge
+        const ox_ = ey * nz - ez * ny;
+        const oy_ = ez * nx - ex * nz;
+        const oz_ = ex * ny - ey * nx;
+        if (ldx * ox_ + ldy * oy_ + ldz * oz_ < 0) edges |= 1 << k;
+    }
+    if (edges === 0) return 0;
+
+    // A heightmap's neighbours are its grid's, found without a search.
+    const heightmap = triangle_edge_shape.isHeightMapShape3D === true;
+    if (heightmap) {
+        edges &= heightmap_unshared_edges(triangle_edge_shape);
+        if (edges === 0) return 0;
+    }
+
+    if (triangle_edge_shape.isMeshShape3D === true) {
+        const flags = triangle_edge_flags(triangle_edge_shape, triangle_buffer, triangle_offset);
+        for (let k = 0; k < 3; k++) {
+            if ((flags & ((TriangleEdgeFlags.FlatAB | TriangleEdgeFlags.ConcaveAB) << k)) !== 0) edges &= ~(1 << k);
+        }
+        if (edges === 0) return 0;
+    }
+
+    // straddling the plane?
+    const tr = triangle_tr;
+    v3_quaternion_apply(
+        plane_normal, 0,
+        triangle_plane_local[0], triangle_plane_local[1], triangle_plane_local[2],
+        tr.rotation_x, tr.rotation_y, tr.rotation_z, tr.rotation_w
+    );
+    const wnx = plane_normal[0], wny = plane_normal[1], wnz = plane_normal[2];
+    swept_posed.px = ox; swept_posed.py = oy; swept_posed.pz = oz;
+    plane_normal_reversed[0] = -wnx;
+    plane_normal_reversed[1] = -wny;
+    plane_normal_reversed[2] = -wnz;
+    swept_posed.support(support_point, 0, plane_normal_reversed, 0);
+    const reach_near = (ox - support_point[0]) * wnx + (oy - support_point[1]) * wny + (oz - support_point[2]) * wnz;
+    if (!(reach_near - triangle_edge_nearest > (skip_initial_overlaps ? PENETRATION_SLOP + CONTACT_EPSILON : CONTACT_EPSILON))) return 0;
+
+    if (heightmap) return edges;
+
+    // The faces across each edge: keep the edges with none, or more than one. A
+    // face that only doubles this one — its back (the same three vertices, or
+    // folded flat back over it across the edge), or a second copy of a face
+    // already counted (the same far vertex) — is no neighbour: a double-sided
+    // quad's rim is still a rim, and its diagonal is still between two faces.
+    //
+    // The candidates for an edge are the triangles with an edge of its hash
+    // ({@link build_edge_index}), walked in buffer order: every triangle with
+    // both of its vertices is among them.
+    if (edge_index_generation !== buffer_generation) build_edge_index();
+
+    const buffer = triangle_buffer;
+    const mask = edge_mask;
+    const hv0 = vertex_hash(v[0], v[1], v[2]);
+    const hv1 = vertex_hash(v[3], v[4], v[5]);
+    const hv2 = vertex_hash(v[6], v[7], v[8]);
+    const self = triangle_offset / TRIANGLE_FLOAT_STRIDE;
+
+    for (let k = 0; k < 3; k++) {
+        if ((edges & (1 << k)) === 0) continue;
+
+        const key = edge_key(k === 0 ? hv0 : k === 1 ? hv1 : hv2, k === 0 ? hv1 : k === 1 ? hv2 : hv0);
+        if (edge_seen_stamp === 0x7FFFFFFF) {
+            edge_seen.fill(0);
+            edge_seen_stamp = 0;
+        }
+        const stamp = ++edge_seen_stamp;
+        let across_k = 0;
+        const c = 3 * k;
+
+        for (let e = edge_heads[key & mask]; e !== -1; e = edge_next[e]) {
+            if (edge_hash[e] !== key) continue;
+            const t = edge_triangle[e];
+            if (t === self || edge_seen[t] === stamp) continue;
+            edge_seen[t] = stamp;
+
+            const o = t * TRIANGLE_FLOAT_STRIDE;
+
+            // which of this triangle's vertices that one has, and its vertex that is none of them
+            let has = 0;
+            let far = -1;
+            for (let j = 0; j < 9; j += 3) {
+                const x = buffer[o + j], y = buffer[o + j + 1], z = buffer[o + j + 2];
+                if (x === v[0] && y === v[1] && z === v[2]) has |= 1;
+                else if (x === v[3] && y === v[4] && z === v[5]) has |= 2;
+                else if (x === v[6] && y === v[7] && z === v[8]) has |= 4;
+                else far = o + j;
+            }
+            // across this edge, and not this very triangle again
+            if ((has === 3 ? 0 : has === 6 ? 1 : has === 5 ? 2 : -1) !== k || far < 0) continue;
+
+            const fx = buffer[far], fy = buffer[far + 1], fz = buffer[far + 2];
+            if (folds_back(k, fx, fy, fz)) continue;
+
+            if (across_k > 0 && across_far[c] === fx && across_far[c + 1] === fy && across_far[c + 2] === fz) continue;
+            if (across_k === 0) {
+                across_far[c] = fx; across_far[c + 1] = fy; across_far[c + 2] = fz;
+            }
+            across_k++;
+        }
+
+        if (across_k === 1) edges &= ~(1 << k);
+    }
+
+    return edges;
+}
+
+/** The far vertex of the first face found across each edge of the triangle under test. */
+const across_far = new Float64Array(9);
+
+/**
+ * Which edges of a heightmap's triangle under test have no neighbour in {@link triangle_buffer}: bit
+ * `k` for edge `k`, as {@link triangle_edges_to_sweep} numbers them.
+ *
+ * A heightmap's adjacency is its grid's. The enumerator emits sub-cell `(i, j)` as triangle 0 `(A, D,
+ * B)` and triangle 1 `(D, C, B)` (A, B, C, D its corners `(i, j)`, `(i + 1, j)`, `(i + 1, j + 1)`,
+ * `(i, j + 1)`), every shared corner written identically, in feature-id order. So the face across each
+ * edge is known from the triangle's own feature id: across the diagonal, the cell's other triangle;
+ * across a side, the next cell's triangle on that side, or none at the grid's border. And whether the
+ * buffer holds it is a binary search of the feature ids — what a search of the buffer for a triangle
+ * with both of the edge's vertices finds, without the search. No face of a heightmap doubles another
+ * or folds back over it.
+ *
+ * @param {import("../../../core/geom/3d/shape/HeightMapShape3D.js").HeightMapShape3D} shape
+ * @returns {number}
+ */
+function heightmap_unshared_edges(shape) {
+    const fid = triangle_buffer[triangle_offset + TRIANGLE_FEATURE_ID_OFFSET] - 1;
+    const sampler = shape.sampler;
+    const seg_u = (sampler.width - 1) * shape.tessellation;
+    const seg_v = (sampler.height - 1) * shape.tessellation;
+
+    const cell = fid >> 1;
+    const i = cell % seg_u;
+    const j = (cell - i) / seg_u;
+
+    let unshared = 0;
+
+    if ((fid & 1) === 0) {
+        // (A, D, B): A→D the side at u = i, D→B the diagonal, B→A the side at v = j
+        if (!(i > 0 && buffer_holds_feature(cell - 1, 1))) unshared |= 1;
+        if (!buffer_holds_feature(cell, 1)) unshared |= 2;
+        if (!(j > 0 && buffer_holds_feature(cell - seg_u, 1))) unshared |= 4;
+    } else {
+        // (D, C, B): D→C the side at v = j + 1, C→B the side at u = i + 1, B→D the diagonal
+        if (!(j < seg_v - 1 && buffer_holds_feature(cell + seg_u, 0))) unshared |= 1;
+        if (!(i < seg_u - 1 && buffer_holds_feature(cell + 1, 0))) unshared |= 2;
+        if (!buffer_holds_feature(cell, 0)) unshared |= 4;
+    }
+
+    return unshared;
+}
+
+/**
+ * Whether the first {@link triangle_count} triangles of {@link triangle_buffer}, a heightmap's in
+ * feature-id order, include triangle `t` of sub-cell `cell`.
+ *
+ * @param {number} cell
+ * @param {number} t 0 or 1
+ * @returns {boolean}
+ */
+function buffer_holds_feature(cell, t) {
+    const fid = cell * 2 + t + 1;
+    let lo = 0, hi = triangle_count - 1;
+    while (lo <= hi) {
+        const mid = (lo + hi) >>> 1;
+        const f = triangle_buffer[mid * TRIANGLE_FLOAT_STRIDE + TRIANGLE_FEATURE_ID_OFFSET];
+        if (f < fid) lo = mid + 1;
+        else if (f > fid) hi = mid - 1;
+        else return true;
     }
     return false;
 }
 
+/**
+ * The edges of the triangles in {@link triangle_buffer}, hashed by their two vertices, for the
+ * neighbour search in {@link triangle_edges_to_sweep}: a chain of the triangles having an edge of each
+ * hash, in buffer order, so that a search walks only the triangles that may share the edge rather
+ * than every triangle under the sweep — a search per triangle over all of them was quadratic, 10 s of
+ * a 2.4 m slide over a 720,000-triangle heightmap. Built on the first search after the buffer is
+ * refilled ({@link buffer_generation}).
+ */
+let edge_heads = new Int32Array(0);
+/** The buckets of {@link edge_heads} the last build used, less one: a power of two less one. */
+let edge_mask = 0;
+let edge_next = new Int32Array(0);
+let edge_hash = new Int32Array(0);
+let edge_triangle = new Int32Array(0);
+/** Per triangle, the search that last walked it, so a chain listing it twice is walked once. */
+let edge_seen = new Int32Array(0);
+let edge_seen_stamp = 0;
+/** The {@link buffer_generation} the index was built for. */
+let edge_index_generation = -1;
+/** Bumped by every enumeration into {@link triangle_buffer}. */
+let buffer_generation = 0;
+
+const hash_f64 = new Float64Array(1);
+const hash_u32 = new Uint32Array(hash_f64.buffer);
+
+/**
+ * A hash of a vertex that equal coordinates share, as `===` has them equal: `-0` with `0`.
+ *
+ * @param {number} x
+ * @param {number} y
+ * @param {number} z
+ * @returns {number}
+ */
+function vertex_hash(x, y, z) {
+    hash_f64[0] = x + 0;
+    let h = Math.imul(hash_u32[0] ^ 0x811c9dc5, 0x01000193) ^ hash_u32[1];
+    hash_f64[0] = y + 0;
+    h = Math.imul(h ^ hash_u32[0], 0x01000193) ^ hash_u32[1];
+    hash_f64[0] = z + 0;
+    h = Math.imul(h ^ hash_u32[0], 0x01000193) ^ hash_u32[1];
+    return lowbias32(h);
+}
+
+/**
+ * Index the first {@link triangle_count} triangles of {@link triangle_buffer} by their edges.
+ */
+function build_edge_index() {
+    const count = triangle_count;
+    const entries = count * 3;
+
+    let size = 16;
+    while (size < 2 * entries) size *= 2;
+    if (edge_heads.length < size) edge_heads = new Int32Array(size);
+    if (edge_next.length < entries) {
+        edge_next = new Int32Array(entries);
+        edge_hash = new Int32Array(entries);
+        edge_triangle = new Int32Array(entries);
+    }
+    if (edge_seen.length < count) {
+        edge_seen = new Int32Array(Math.max(count, edge_seen.length * 2));
+        edge_seen_stamp = 0;
+    }
+
+    const mask = size - 1;
+    edge_mask = mask;
+    edge_heads.fill(-1, 0, size);
+
+    const buffer = triangle_buffer;
+    let e = 0;
+    // last to first, each pushed onto the front of its chain: the chains run in buffer order
+    for (let t = count - 1; t >= 0; t--) {
+        const o = t * TRIANGLE_FLOAT_STRIDE;
+        const ha = vertex_hash(buffer[o], buffer[o + 1], buffer[o + 2]);
+        const hb = vertex_hash(buffer[o + 3], buffer[o + 4], buffer[o + 5]);
+        const hc = vertex_hash(buffer[o + 6], buffer[o + 7], buffer[o + 8]);
+
+        for (let k = 0; k < 3; k++) {
+            const h = edge_key(k === 0 ? ha : k === 1 ? hb : hc, k === 0 ? hb : k === 1 ? hc : ha);
+            const bucket = h & mask;
+            edge_hash[e] = h;
+            edge_triangle[e] = t;
+            edge_next[e] = edge_heads[bucket];
+            edge_heads[bucket] = e;
+            e++;
+        }
+    }
+
+    edge_index_generation = buffer_generation;
+}
+
+/**
+ * The hash of an edge, whichever way round its vertices come.
+ *
+ * @param {number} ha
+ * @param {number} hb
+ * @returns {number}
+ */
+function edge_key(ha, hb) {
+    return lowbias32((ha + hb) | 0) | 0;
+}
+
+/**
+ * Whether a face across edge `k` of the triangle under test, whose vertex off
+ * the edge is `(fx, fy, fz)`, is folded flat back over the triangle: in its
+ * plane, on its side of the edge — a back face, however its quad was split.
+ *
+ * @param {number} k
+ * @param {number} fx
+ * @param {number} fy
+ * @param {number} fz
+ * @returns {boolean}
+ */
+function folds_back(k, fx, fy, fz) {
+    const v = triangle_local;
+    const a = 3 * k, b = 3 * ((k + 1) % 3), c = 3 * ((k + 2) % 3);
+    const ex = v[b] - v[a], ey = v[b + 1] - v[a + 1], ez = v[b + 2] - v[a + 2];
+    const cx = v[c] - v[a], cy = v[c + 1] - v[a + 1], cz = v[c + 2] - v[a + 2];
+    const qx = fx - v[a], qy = fy - v[a + 1], qz = fz - v[a + 2];
+
+    // the triangle's normal, and the far vertex's height above its plane
+    const nx = ey * cz - ez * cy, ny = ez * cx - ex * cz, nz = ex * cy - ey * cx;
+    const height = nx * qx + ny * qy + nz * qz;
+    const n_sqr = nx * nx + ny * ny + nz * nz;
+    if (height * height > 1e-12 * n_sqr * (qx * qx + qy * qy + qz * qz)) return false;
+
+    // in the plane: on the triangle's side of the edge?
+    const sx = ey * qz - ez * qy, sy = ez * qx - ex * qz, sz = ex * qy - ey * qx;
+    return nx * sx + ny * sy + nz * sz > 0;
+}
+
+/**
+ * Sweep against edges `edges` (bits, as {@link triangle_edges_to_sweep}) of the
+ * triangle under test, each one a segment cast as a convex candidate of its
+ * own.
+ *
+ * @param {number} ox
+ * @param {number} oy
+ * @param {number} oz
+ * @param {number} dx
+ * @param {number} dy
+ * @param {number} dz
+ * @param {number} t_limit
+ * @param {number} stop_width
+ * @param {boolean} skip_initial_overlaps
+ * @param {number} edges
+ * @returns {number} the nearest edge's time of impact, or {@link CAST_MISS};
+ *   {@link cast_has_normal} / {@link cast_normal} as {@link cast_candidate}
+ */
+function cast_triangle_edges(ox, oy, oz, dx, dy, dz, t_limit, stop_width, skip_initial_overlaps, edges) {
+    const tr = triangle_tr;
+    const qx = tr.rotation_x, qy = tr.rotation_y, qz = tr.rotation_z, qw = tr.rotation_w;
+    const v = triangle_local;
+
+    let best = CAST_MISS;
+    let best_contact = t_limit;
+    let best_has_normal = false;
+    /** Under CCD, whether the shape was found clear of the whole triangle at the start. */
+    let clear_at_start = !skip_initial_overlaps;
+
+    for (let k = 0; k < 3; k++) {
+        if ((edges & (1 << k)) === 0) continue;
+
+        const a = 3 * k;
+        const b = 3 * ((k + 1) % 3);
+        const mx = (v[a] + v[b]) * 0.5;
+        const my = (v[a + 1] + v[b + 1]) * 0.5;
+        const mz = (v[a + 2] + v[b + 2]) * 0.5;
+        edge_vertices[0] = v[a] - mx; edge_vertices[1] = v[a + 1] - my; edge_vertices[2] = v[a + 2] - mz;
+        edge_vertices[3] = v[b] - mx; edge_vertices[4] = v[b + 1] - my; edge_vertices[5] = v[b + 2] - mz;
+        edge_vertices[6] = edge_vertices[3]; edge_vertices[7] = edge_vertices[4]; edge_vertices[8] = edge_vertices[5];
+
+        v3_quaternion_apply(anchor_world, 0, mx, my, mz, qx, qy, qz, qw);
+        candidate_posed.setup_components(
+            edge_shape,
+            tr.translation_x + anchor_world[0], tr.translation_y + anchor_world[1], tr.translation_z + anchor_world[2],
+            qx, qy, qz, qw
+        );
+
+        // A segment is convex: cast as one, its normal probes read it, not the triangle.
+        candidate_is_triangle = false;
+        const t = cast_candidate(
+            ox, oy, oz, dx, dy, dz, best_contact, stop_width, skip_initial_overlaps,
+            -Infinity, Infinity
+        );
+        candidate_is_triangle = true;
+        if (t === CAST_MISS || !(cast_touch_t < best_contact)) continue;
+
+        if (!clear_at_start) {
+            // Under CCD a triangle the shape starts in is a resting contact to
+            // step over, edges and all — a ball resting in an open floor by an
+            // obtuse corner reaches past the line of the corner's edge beside
+            // it, and can come onto the edge from outside.
+            anchor_triangle(
+                (v[0] + v[3] + v[6]) / 3, (v[1] + v[4] + v[7]) / 3, (v[2] + v[5] + v[8]) / 3
+            );
+            swept_posed.px = ox; swept_posed.py = oy; swept_posed.pz = oz;
+            if (gjk(simplex_buf, swept_posed, candidate_posed)) {
+                best = CAST_MISS;
+                best_has_normal = false;
+                break;
+            }
+            clear_at_start = true;
+        }
+
+        best = t === CAST_BLOCKED ? 0 : t;
+        best_contact = cast_touch_t;
+        best_has_normal = cast_has_normal;
+        if (cast_has_normal) edge_normal.set(cast_normal);
+        if (best === 0) break;
+    }
+
+    cast_face = false;
+    cast_has_normal = best_has_normal;
+    if (best_has_normal) cast_normal.set(edge_normal);
+    cast_touch_t = best_contact;
+    return best;
+}
+
+/**
+ * Conservative advancement of `swept_posed` toward `candidate_posed` along the
+ * sweep from `t_start`, after Box3D's `b3ShapeCast` (distance.c, MIT, Erin
+ * Catto): the distance kernel gives a plane separating the two, and nothing can
+ * touch before the sweep closes that plane's gap, so the shape steps across it
+ * in one move, to {@link ADVANCE_TARGET} short of it, and asks again. A flat
+ * approach lands in one step; no feature, however thin or oblique, can be
+ * stepped over, because no step is ever longer than the gap to it.
+ *
+ * Arriving within the target is a TOUCH, not yet a hit — a sphere sliding
+ * along a wall touches it everywhere and never enters it. So a touch is
+ * followed one step further, to where it would be {@link ADVANCE_TARGET} deep
+ * at its present rate of approach: if the shapes overlap there, the sweep
+ * enters the candidate and the touch is the hit. If not, the advancement goes
+ * on from there. It ends as soon as the sweep stops closing: the distance
+ * along a translation is convex, so once it stops falling it never falls
+ * again — a graze is a miss, as it was when only overlap counted.
+ *
+ * Box3D answers an advancement that runs out of iterations with a silent
+ * miss. Here it falls back on the bracket search over what is left of the
+ * window, and says so once per process.
+ *
+ * On a hit, {@link cast_normal} holds the separating direction at the touch.
+ *
+ * @param {number} ox
+ * @param {number} oy
+ * @param {number} oz
+ * @param {number} dx unit sweep direction
+ * @param {number} dy
+ * @param {number} dz
+ * @param {number} t_start nothing touches before this
+ * @param {number} t_end nothing can start touching after this
+ * @param {number} stop_width the bracket search's resolution
+ * @returns {number} the time of impact, or {@link CAST_MISS}
+ */
+function advance_to_contact(ox, oy, oz, dx, dy, dz, t_start, t_end, stop_width) {
+    distance_simplex.count = 0;
+
+    let t = t_start;
+    swept_posed.px = ox + dx * t;
+    swept_posed.py = oy + dy * t;
+    swept_posed.pz = oz + dz * t;
+
+    /** A touch being followed: its time, or -1. */
+    let t_touch = -1;
+    /** When the contact behind that touch begins: the touch plus its gap over the closing speed. */
+    let touch_contact = 0;
+    /** The last time the shapes were measured apart. */
+    let t_apart = t_start;
+
+    for (let iteration = 0; iteration < ADVANCE_MAX_ITERATIONS; iteration++) {
+        let distance = gjk_distance(distance_result, distance_simplex, candidate_posed, swept_posed, ADVANCE_DISTANCE_TOLERANCE);
+        if (distance > 0 && distance_result[9] <= ADVANCE_TARGET + ADVANCE_TOLERANCE
+            && distance - distance_result[9] > GJK_DISTANCE_RELATIVE_GAP * distance) {
+            // A touch, or nearly, that the tolerance stopped short of exact:
+            // its gap and normal are what is judged and reported, so the search
+            // goes on from where it stopped to the kernel's own precision. (A
+            // polytope pair ends exact on a repeated support either way.)
+            distance = gjk_distance(distance_result, distance_simplex, candidate_posed, swept_posed, 0);
+        }
+        if (distance > 0 && !(distance_result[9] > 0)) {
+            // The search ran out of iterations before any plane separated the
+            // two, so `distance` is only how close it came. Ask again from
+            // nothing: a simplex carried across steps can stall where a fresh
+            // one does not (a 1,000 m sphere 1e-5 from a small one, 106 times
+            // in 400 carried, 10 fresh).
+            distance_simplex.count = 0;
+            distance = gjk_distance(distance_result, distance_simplex, candidate_posed, swept_posed, 0);
+            if (distance > 0 && !(distance_result[9] > 0)) {
+                // Still nothing to step by, and no reason to call it a touch:
+                // the bracket search settles it from the last pose known apart.
+                return bracket_search(ox, oy, oz, dx, dy, dz, t_apart, t_end, stop_width);
+            }
+        }
+
+        // In contact: the search ended on its own terms with no plane between
+        // the two.
+        if (distance === 0) {
+            if (gjk(simplex_buf, swept_posed, candidate_posed)) {
+                // Overlap. Behind a touch, that is the hit: the shapes were
+                // apart at the touch and are in contact one step on.
+                if (t_touch >= 0) {
+                    cast_has_normal = true;
+                    cast_touch_t = touch_contact;
+                    return t_touch;
+                }
+
+                // Anywhere else the step that led here was supposed to be
+                // safe, and only numerics put it inside. The bracket search
+                // settles it from the last pose known apart.
+                return bracket_search(ox, oy, oz, dx, dy, dz, t_apart, t_end, stop_width);
+            }
+
+            // Exactly touching — a shape flush with a face it slides along, or
+            // a step that landed on the contact to the last bit. The distance
+            // has no normal to give, so it is read by penetration, as a touch
+            // at the start of the sweep is, and the rule is the same: only a
+            // sweep driving into the touch enters it (see `cast_candidate`).
+            const px = swept_posed.px, py = swept_posed.py, pz = swept_posed.pz;
+            if (!recover_contact_normal(probe_normal, px, py, pz, dx, dy, dz)) {
+                // No normal to judge by: stopping short is the safe failure.
+                cast_touch_t = t_touch >= 0 ? touch_contact : t;
+                return t_touch >= 0 ? t_touch : t;
+            }
+            if (dx * probe_normal[0] + dy * probe_normal[1] + dz * probe_normal[2] > -GRAZING_SINE_EPSILON) {
+                return CAST_MISS;
+            }
+            if (t_touch < 0) {
+                cast_normal[0] = probe_normal[0]; cast_normal[1] = probe_normal[1]; cast_normal[2] = probe_normal[2];
+            }
+            cast_has_normal = true;
+            cast_touch_t = t_touch >= 0 ? touch_contact : t;
+            return t_touch >= 0 ? t_touch : t;
+        }
+        t_apart = t;
+
+        const nx = distance_result[6], ny = distance_result[7], nz = distance_result[8];
+        const gap = distance_result[9];
+
+        // Closing speed along the separating normal, per unit of sweep.
+        const closing = -(dx * nx + dy * ny + dz * nz);
+        if (!(closing > 0)) return CAST_MISS;
+
+        let t_next;
+        if (gap <= ADVANCE_TARGET + ADVANCE_TOLERANCE) {
+            t_touch = t;
+            touch_contact = t + gap / closing;
+            cast_normal[0] = nx; cast_normal[1] = ny; cast_normal[2] = nz;
+            t_next = t + (gap + ADVANCE_TARGET) / closing;
+            // Only a contact strictly before `t_end` counts, so that is as far
+            // as it needs to be followed.
+            if (t_next > t_end) t_next = t_end;
+            if (!(t_next > t)) return CAST_MISS;
+        } else {
+            t_touch = -1;
+            t_next = t + (gap - ADVANCE_TARGET) / closing;
+            if (!(t_next < t_end)) return CAST_MISS;
+        }
+
+        const step = t_next - t;
+        swept_posed.px = ox + dx * t_next;
+        swept_posed.py = oy + dy * t_next;
+        swept_posed.pz = oz + dz * t_next;
+        gjk_simplex_translate_b(distance_simplex, dx * step, dy * step, dz * step);
+        t = t_next;
+    }
+
+    if (!advance_exhaustion_reported) {
+        advance_exhaustion_reported = true;
+        console.warn(
+            `shape_cast: conservative advancement did not converge in ${ADVANCE_MAX_ITERATIONS} steps`
+            + ` (at t = ${t} of a window ending at ${t_end}); falling back on the bracket search.`
+        );
+    }
+    return bracket_search(ox, oy, oz, dx, dy, dz, t_apart, t_end, stop_width);
+}
+
+/**
+ * The time of impact by sampling: a coarse scan of `[t_start, t_end]` for an
+ * overlapping moment, then bisection down to `stop_width`. What every sweep
+ * used before {@link advance_to_contact}, and what it falls back on; a feature
+ * thinner than a sample's spacing is stepped over (see {@link COARSE_STEPS}).
+ *
+ * @param {number} ox
+ * @param {number} oy
+ * @param {number} oz
+ * @param {number} dx
+ * @param {number} dy
+ * @param {number} dz
+ * @param {number} t_start not overlapping here
+ * @param {number} t_end
+ * @param {number} stop_width
+ * @returns {number} the just-SEPARATING side of the bisection, or {@link CAST_MISS}
+ */
+function bracket_search(ox, oy, oz, dx, dy, dz, t_start, t_end, stop_width) {
+    cast_has_normal = false;
+
+    if (!(t_start < t_end)) return CAST_MISS;
+
+    // Coarse-search within the narrowed interval to find any t for
+    // which the shapes overlap (their AABBs do by construction; the
+    // shapes themselves may not, e.g. two spheres passing alongside).
+    const step_dt = (t_end - t_start) / COARSE_STEPS;
+    let t_prev = t_start;
+    let t_hi = -1;
+    for (let s = 1; s <= COARSE_STEPS; s++) {
+        const t = t_start + s * step_dt;
+        swept_posed.px = ox + dx * t;
+        swept_posed.py = oy + dy * t;
+        swept_posed.pz = oz + dz * t;
+        if (gjk(simplex_buf, swept_posed, candidate_posed)) {
+            t_hi = t;
+            break;
+        }
+        t_prev = t;
+    }
+    if (t_hi < 0) return CAST_MISS;
+
+    // Bisect [t_prev, t_hi]: invariant is `gjk(t_lo) === false` and
+    // `gjk(t_hi) === true`.
+    let t_lo = t_prev;
+    for (let bi = 0; bi < MAX_BISECTION && (t_hi - t_lo) > stop_width; bi++) {
+        const t_mid = (t_lo + t_hi) * 0.5;
+        swept_posed.px = ox + dx * t_mid;
+        swept_posed.py = oy + dy * t_mid;
+        swept_posed.pz = oz + dz * t_mid;
+        if (gjk(simplex_buf, swept_posed, candidate_posed)) {
+            t_hi = t_mid;
+        } else {
+            t_lo = t_mid;
+        }
+    }
+
+    // Use t_lo (the just-SEPARATING side of the bisection) rather
+    // than t_hi (just-overlapping). With the fixed GJK that no
+    // longer flags 5 mm-clear gaps as overlap, the bisection is
+    // tight; reporting t_lo gives kinematic callers a conservative
+    // TOI — the swept shape at the reported moment is provably NOT
+    // overlapping the target. The normal-probe in `shape_cast` steps a
+    // few mm past it to get a valid simplex for MPR.
+    cast_touch_t = t_lo;
+    return t_lo;
+}
+
+/**
+ * The world box the swept shape covers over `[t0, t1]` of the sweep along unit
+ * `(dx, dy, dz)`, from the shape's box at the origin, {@link initial_aabb};
+ * written into {@link piece_aabb}.
+ *
+ * @param {number} dx
+ * @param {number} dy
+ * @param {number} dz
+ * @param {number} t0
+ * @param {number} t1
+ * @returns {Float64Array} {@link piece_aabb}
+ */
+function sweep_piece_aabb(dx, dy, dz, t0, t1) {
+    const sx0 = dx * t0, sx1 = dx * t1;
+    const sy0 = dy * t0, sy1 = dy * t1;
+    const sz0 = dz * t0, sz1 = dz * t1;
+    piece_aabb[0] = initial_aabb[0] + (sx0 < sx1 ? sx0 : sx1);
+    piece_aabb[1] = initial_aabb[1] + (sy0 < sy1 ? sy0 : sy1);
+    piece_aabb[2] = initial_aabb[2] + (sz0 < sz1 ? sz0 : sz1);
+    piece_aabb[3] = initial_aabb[3] + (sx0 > sx1 ? sx0 : sx1);
+    piece_aabb[4] = initial_aabb[4] + (sy0 > sy1 ? sy0 : sy1);
+    piece_aabb[5] = initial_aabb[5] + (sz0 > sz1 ? sz0 : sz1);
+    return piece_aabb;
+}
+
+/**
+ * Enumerate the triangles of concave `shape`, posed at `target_tr`, that may
+ * overlap the world AABB `world_aabb` into {@link triangle_buffer}, in the
+ * shape's own frame — the same decomposition the narrowphase and
+ * `overlap_shape` use.
+ *
+ * The enumerator returns the TRUE count and drops what does not fit; a
+ * dropped triangle is a hole the sweep would pass straight through, so the
+ * buffer grows and the enumeration re-runs (deterministic → one resize) — up to
+ * {@link MAX_TRIANGLES_PER_PAIR}, and no further. Past that, the count returned
+ * is still the true one and only the first that many are in the buffer: the
+ * caller walks the sweep in shorter pieces (see `shape_cast`).
+ *
+ * @param {AbstractShape3D} shape
+ * @param {Transform64} target_tr
+ * @param {Float64Array} world_aabb
+ * @returns {number} the triangles overlapping the box, which may be more than
+ *   {@link MAX_TRIANGLES_PER_PAIR}
+ */
+function enumerate_triangles(shape, target_tr, world_aabb) {
+    aabb3_transform_oriented_inverse(
+        concave_query_aabb, 0,
+        world_aabb,
+        target_tr.translation_x, target_tr.translation_y, target_tr.translation_z,
+        target_tr.rotation_x, target_tr.rotation_y, target_tr.rotation_z, target_tr.rotation_w
+    );
+
+    buffer_generation++;
+
+    for (;;) {
+        const count = decompose_to_triangles(
+            triangle_buffer, 0, 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]
+        );
+        const capacity = triangle_buffer.length / TRIANGLE_FLOAT_STRIDE;
+        if (count <= capacity || capacity >= MAX_TRIANGLES_PER_PAIR) return count;
+        triangle_buffer = new Float64Array(
+            Math.min(MAX_TRIANGLES_PER_PAIR, Math.max(count, capacity * 2)) * TRIANGLE_FLOAT_STRIDE
+        );
+    }
+}
+
+/**
+ * The count {@link enumerate_triangles} would return for the same box, for
+ * sizing a piece of the walk. A heightmap's is counted in O(1)
+ * ({@link heightmap_box_triangles}) and nothing is enumerated — the caller
+ * enumerates the piece it settles on; a mesh's is enumerated, as its count can
+ * only be had that way.
+ *
+ * @param {AbstractShape3D} shape
+ * @param {Transform64} target_tr
+ * @param {Float64Array} world_aabb
+ * @returns {number}
+ */
+function count_triangles(shape, target_tr, world_aabb) {
+    if (shape.isHeightMapShape3D !== true) {
+        return enumerate_triangles(shape, target_tr, world_aabb);
+    }
+
+    aabb3_transform_oriented_inverse(
+        concave_query_aabb, 0,
+        world_aabb,
+        target_tr.translation_x, target_tr.translation_y, target_tr.translation_z,
+        target_tr.rotation_x, target_tr.rotation_y, target_tr.rotation_z, target_tr.rotation_w
+    );
+
+    return heightmap_box_triangles(
+        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]
+    );
+}
+
+/**
+ * Make the triangle at `offset` of `buffer` (in the frame of a collider posed
+ * at `target_tr`) the one under test, posed as `candidate_posed` anchored at
+ * its centroid.
+ *
+ * @param {Float64Array} buffer
+ * @param {number} offset
+ * @param {Transform64} target_tr
+ */
+function set_triangle(buffer, offset, target_tr) {
+    for (let i = 0; i < 9; i++) triangle_local[i] = buffer[offset + i];
+    triangle_tr = target_tr;
+    candidate_is_triangle = true;
+
+    anchor_triangle(
+        (triangle_local[0] + triangle_local[3] + triangle_local[6]) / 3,
+        (triangle_local[1] + triangle_local[4] + triangle_local[7]) / 3,
+        (triangle_local[2] + triangle_local[5] + triangle_local[8]) / 3
+    );
+}
+
+/**
+ * Make the triangle at `offset` of `buffer` — vertices in the frame of a
+ * concave collider posed at `target_tr` — the candidate under test, posed as
+ * `candidate_posed` anchored at its centroid (see {@link triangle_vertices}),
+ * and write the part of the sweep that can touch it into
+ * {@link triangle_window_enter} / {@link triangle_window_exit}.
+ *
+ * A triangle is flat, and that is what the window is read from: the sweep can
+ * touch the triangle only while the swept shape straddles its PLANE, an
+ * interval known in closed form from the shape's reach along the normal. It
+ * matters more than the saving. The coarse search samples 32 points across
+ * whatever interval it is given, and the AABB slab interval of a large
+ * oblique triangle is metres long while the shape crosses its plane in
+ * centimetres — measured on a 40 m ramp at 30° pitch, 225 of 300 casts of a
+ * 5 cm sphere stepped clean over it (as they do over a 1 mm box at the same
+ * pose; a triangle is simply always that thin).
+ *
+ * A sweep that does not CLOSE on the plane gets an empty window: it is tested
+ * for overlap at the start, and the face is never swept. Running parallel to
+ * the plane, or leaving it, the shape cannot enter the face; at most it meets
+ * the triangle's boundary, and only if it already reaches across the plane.
+ * Most of that boundary is no boundary of the surface: a coplanar neighbour
+ * (the next triangle of a floor) is the very surface the shape is sliding on,
+ * and reporting the touch at its seam stops a sliding shape at every seam it
+ * crosses and hands a kinematic caller a contact it rightly judges harmless
+ * while the scan behind it is cut short. So only the edges a sweep can meet
+ * edge-on are swept ({@link triangle_edges_to_sweep}): the surface's own
+ * boundary. Skipping all of them, a quad approached exactly edge-on, or 1e-5
+ * off it, was invisible to every cast.
+ *
+ * What "closing" means follows `skip_initial_overlaps`. Kinematic semantics
+ * are exact: any approach beyond {@link GRAZING_SINE_EPSILON}. Under CCD
+ * semantics the body is usually RESTING in the surface it slides on, already
+ * {@link PENETRATION_SLOP} deep, and its net motion over a step drifts into
+ * the plane by solver noise; a sweep that closes on a plane by no more than
+ * that slop over its whole length, its centre staying on the side it started,
+ * cannot carry the body through anything, and the discrete solver owns that
+ * depth. Measured without it: a CCD sphere sliding at 5 m/s across a flat
+ * heightmap was stopped at a seam often enough to lose 4.2 m of travel in one
+ * second.
+ *
+ * @param {AbstractShape3D} shape the concave shape `buffer` was enumerated from
+ * @param {Float64Array} buffer
+ * @param {number} offset float-index of the triangle in `buffer`
+ * @param {Transform64} target_tr
+ * @param {number} lx sweep origin in the target's frame
+ * @param {number} ly
+ * @param {number} lz
+ * @param {number} ldx unit sweep direction in the target's frame
+ * @param {number} ldy
+ * @param {number} ldz
+ * @param {number} ox sweep origin in world space
+ * @param {number} oy
+ * @param {number} oz
+ * @param {number} tMax sweep length
+ * @param {boolean} skip_initial_overlaps see {@link shape_cast}
+ */
+function load_triangle(
+    shape, buffer, offset, target_tr,
+    lx, ly, lz, ldx, ldy, ldz,
+    ox, oy, oz, tMax, skip_initial_overlaps
+) {
+    set_triangle(buffer, offset, target_tr);
+
+    const ax = triangle_local[0], ay = triangle_local[1], az = triangle_local[2];
+    const bx = triangle_local[3], by = triangle_local[4], bz = triangle_local[5];
+    const cx = triangle_local[6], cy = triangle_local[7], cz = triangle_local[8];
+    const mx = (ax + bx + cx) / 3;
+    const my = (ay + by + cy) / 3;
+    const mz = (az + bz + cz) / 3;
+
+    // Empty until shown otherwise: tested at the start only.
+    triangle_window_enter = Infinity;
+    triangle_window_exit = -Infinity;
+    triangle_start_depth = Infinity;
+    triangle_centre_crossing = Infinity;
+    triangle_edges_pending = false;
+
+    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 n_len = Math.sqrt(nx * nx + ny * ny + nz * nz);
+    // A degenerate (zero-area) triangle has no plane to enter and no
+    // surface of its own; its neighbours carry the geometry.
+    if (!(n_len > 0)) return;
+    const n_inv = 1 / n_len;
+
+    // Orient the unit normal toward the side the sweep starts on; a start IN
+    // the plane has no side, so the normal faces the sweep.
+    const side = ((lx - mx) * nx + (ly - my) * ny + (lz - mz) * nz) * n_inv;
+    const rate = (ldx * nx + ldy * ny + ldz * nz) * n_inv;
+    const sign = side > 0 ? 1 : (side < 0 ? -1 : (rate > 0 ? -1 : 1));
+    const closing = -rate * sign;
+    const distance = side * sign;
+
+    // The CCD slop: a sweep closing on the plane by no more than the solver's
+    // penetration slop is the solver's — unless its centre ends on the far
+    // side, which a body thinner than the slop does while staying inside it.
+    // The discrete solver pushes such a body on through: a 2 mm plate or a
+    // 4 mm sphere approaching a mesh floor at under 5 mm a step passed it in
+    // 23 and 15 of 30 cases.
+    const sweeps_plane = closing > GRAZING_SINE_EPSILON
+        && !(skip_initial_overlaps && !(closing * tMax > PENETRATION_SLOP) && distance - closing * tMax > 0);
+
+    const s = sign * n_inv;
+
+    if (!sweeps_plane) {
+        // Not closing on the plane: only the edges are left to meet, and only
+        // by a shape already reaching across the plane. Which of them, and
+        // whether it does, is worked out only when asked
+        // ({@link triangle_edges_to_sweep}).
+        triangle_edges_pending = true;
+        triangle_edge_shape = shape;
+        triangle_edge_nearest = distance - (closing > 0 ? closing * tMax : 0);
+        triangle_plane_local[0] = nx * s;
+        triangle_plane_local[1] = ny * s;
+        triangle_plane_local[2] = nz * s;
+        return;
+    }
+
+    // The swept shape's reach toward the plane and away from it, from its
+    // supports along the (world) normal at the sweep origin.
+    v3_quaternion_apply(
+        plane_normal, 0,
+        nx * s, ny * s, nz * s,
+        target_tr.rotation_x, target_tr.rotation_y, target_tr.rotation_z, target_tr.rotation_w
+    );
+    const wnx = plane_normal[0], wny = plane_normal[1], wnz = plane_normal[2];
+
+    swept_posed.px = ox; swept_posed.py = oy; swept_posed.pz = oz;
+    plane_normal_reversed[0] = -wnx;
+    plane_normal_reversed[1] = -wny;
+    plane_normal_reversed[2] = -wnz;
+    swept_posed.support(support_point, 0, plane_normal_reversed, 0);
+    const reach_near = (ox - support_point[0]) * wnx + (oy - support_point[1]) * wny + (oz - support_point[2]) * wnz;
+    // the point that reaches the plane first, as the sweep starts
+    triangle_touch_origin[0] = support_point[0];
+    triangle_touch_origin[1] = support_point[1];
+    triangle_touch_origin[2] = support_point[2];
+    swept_posed.support(support_point, 0, plane_normal, 0);
+    const reach_far = (support_point[0] - ox) * wnx + (support_point[1] - oy) * wny + (support_point[2] - oz) * wnz;
+
+    triangle_window_enter = (distance - reach_near) / closing;
+    triangle_window_exit = (distance + reach_far) / closing;
+    triangle_start_depth = reach_near - distance;
+
+    // Where the centre reaches the plane, and whether that is within the
+    // triangle's edges (each edge's cross product agrees with the normal).
+    if (distance >= 0) {
+        const t_cross = distance / closing;
+        const px = lx + ldx * t_cross, py = ly + ldy * t_cross, pz = lz + ldz * t_cross;
+        if (edge_holds(ax, ay, az, bx, by, bz, px, py, pz, nx, ny, nz)
+            && edge_holds(bx, by, bz, cx, cy, cz, px, py, pz, nx, ny, nz)
+            && edge_holds(cx, cy, cz, ax, ay, az, px, py, pz, nx, ny, nz)) {
+            triangle_centre_crossing = t_cross;
+        }
+    }
+}
+
+/**
+ * Whether point `p`, in a triangle's plane, lies on the inner side of (or on)
+ * the triangle's edge from `a` to `b`, the triangle's normal being `n` (from
+ * its winding, either way up).
+ */
+function edge_holds(ax, ay, az, bx, by, bz, px, py, pz, nx, ny, nz) {
+    const ex = bx - ax, ey = by - ay, ez = bz - az;
+    const qx = px - ax, qy = py - ay, qz = pz - az;
+    return nx * (ey * qz - ez * qy) + ny * (ez * qx - ex * qz) + nz * (ex * qy - ey * qx) >= 0;
+}
+
 /**
  * Sweep a convex shape along a ray and find the first body it would
  * hit. Used by character controllers (sweep a capsule along intended
@@ -255,35 +1925,46 @@ function recover_contact_normal(out, cx, cy, cz, dx, dy, dz, target_tr) {
  *      stretched along `ray.direction * ray.tMax`.
  *   2. Query both broadphase BVHs (static + dynamic) for leaves whose
  *      AABB overlaps the swept volume.
- *   3. For each candidate, bisect the [0, best_t] interval for the
- *      smallest `t` at which the swept shape overlaps the candidate's
- *      collider. GJK on each midpoint.
+ *   3. For each candidate, advance the swept shape toward the candidate's
+ *      collider by conservative advancement on the GJK distance (see
+ *      `advance_to_contact`) for the smallest `t` at which it touches and
+ *      goes on into it, within [0, best_t). A concave collider (mesh,
+ *      heightmap) is a surface, not the solid its hull encloses: it is
+ *      swept as the set of its triangles under the swept AABB, each one a
+ *      convex candidate under the same rules.
  *
- * Picking `best_t` (rather than always running the full [0, tMax]
- * bisection) is the early-termination optimisation: once we have a
- * hit at some t, no later candidate can produce a smaller TOI by
- * being checked at its full [0, tMax] interval.
+ * Searching only [0, best_t) (rather than always the full [0, tMax]) is the
+ * early-termination optimisation: once we have a hit at some t, no later
+ * candidate can produce a smaller TOI by being checked over the rest.
  *
  * Output on hit:
  *   - `result.t` — sweep distance to impact (in the same units as
  *     `ray.direction`'s magnitude; for a unit-direction ray, this is
- *     metres).
+ *     metres). The swept shape there is still apart from what it struck
+ *     — by about {@link ADVANCE_TARGET}, or within the bracket search's
+ *     resolution when that found it — so a caller can place a body there.
  *   - `result.position` — `ray.origin + t * ray.direction`, i.e. the
  *     centre of the swept shape at the moment of first contact. NOT
- *     a point on the target's surface; that would need narrowphase
- *     refinement which the broadphase-only architecture doesn't have
- *     wired up yet.
+ *     a point on the target's surface.
  *   - `result.normal` — target surface's outward normal at the kiss
- *     point (unit length), recovered by running MPR against the
- *     just-overlapping configuration at the TOI. A pair that is exactly
- *     tangent there carries no MTV to read, so a second probe nudged
- *     toward the target's centre supplies one; `-ray.direction` remains
- *     the last-resort fallback if both degenerate. See the
- *     contact-normal recovery block near the end of the function.
+ *     point (unit length): the separating direction advancement stopped
+ *     on, or a triangle face's own normal. A cast blocked where it starts
+ *     reads it off by MPR, and a pair exactly tangent there carries no MTV
+ *     to read, so a second probe nudged toward the target's centre
+ *     supplies one; `-ray.direction` remains the last-resort fallback if
+ *     both degenerate. See the contact-normal block near the end of the
+ *     function.
  *   - `result.entity` / `result.body_id` — the hit body.
+ *   - `result.collider_entity` — the entity owning the struck collider (a
+ *     compound body's child's own); `result.triangle` — the struck triangle of
+ *     a mesh or heightmap collider, `-1` for any other.
  *
  * Output on miss: untouched; same convention as `raycast`.
  *
+ * The filter may run a raycast or an overlap of its own, but not another cast:
+ * a cast keeps its working state in module scratch, and one started from its
+ * filter is refused by an assert.
+ *
  * @param {PhysicsSystem} system
  * @param {Ray3|{origin_x:number,origin_y:number,origin_z:number,direction_x:number,direction_y:number,direction_z:number,tMax:number}} ray
  *   origin + unit direction + `tMax`. Only the named accessors are read, so a
@@ -293,30 +1974,61 @@ function recover_contact_normal(out, cx, cy, cz, dx, dy, dz, target_tr) {
  * @param {ArrayLike<number>} rotation  the orientation the shape is held at for
  *   the whole sweep, read BY INDEX as `[x, y, z, w]` and taken to be a unit
  *   quaternion (it is neither normalised nor validated here — a non-unit one
- *   silently returns wrong answers). A `Transform64`'s `rotation` (a
- *   `Float64Array` view — what the CCD pass hands in), a `Quaternion`
+ *   silently returns wrong answers). A retained `Float64Array` (what the CCD
+ *   pass hands in: the body's orientation copied out of its Transform64, whose
+ *   `rotation` accessor allocates a view per read), a `Quaternion`
  *   (`Float64Array`-backed) and a plain `[x, y, z, w]` array all satisfy that;
  *   an `{x, y, z, w}` object does NOT — its components read as `undefined`,
  *   the swept AABB comes out NaN, and every cast then misses silently
  * @param {PhysicsSurfacePoint} result  populated on hit; untouched on miss
  * @param {(entity:number, collider:Collider, body_id:number)=>boolean} [filter]
- *   mandatory in contract; defaults to {@link returnTrue}. Receives the
- *   candidate body's entity, primary collider, and packed body id (the id
- *   distinguishes bodies when colliders live on child entities)
+ *   mandatory in contract; defaults to {@link returnTrue}. Called once per
+ *   collider of each candidate body, with the body's entity, that collider,
+ *   and the packed body id (the id distinguishes bodies when colliders live on
+ *   child entities)
  * @param {boolean} [skip_initial_overlaps=false] how a candidate ALREADY
  *   overlapping the swept shape at `t = 0` is treated. `false` (kinematic
  *   "can I move?" semantics): targets are solid, so the cast is blocked where
- *   it stands — report a hit at `t = 0`. The one exception is a convex target
+ *   it stands — report a hit at `t = 0`. The one exception is a target
  *   the shape merely TOUCHES (no depth beyond {@link CONTACT_EPSILON}): a
  *   tangency blocks only a sweep driving into it, and otherwise steps aside so
  *   the scan can reach real blockers. `true` (CCD semantics): such a candidate
  *   is a resting / sliding contact the discrete solver already owns, NOT a
  *   tunnelling threat — skip it and keep scanning the remaining candidates for
  *   real blockers along the sweep. Either way, one contact at the start of the
- *   sweep must never blind the cast to every other obstacle.
+ *   sweep must never blind the cast to every other obstacle. For a concave
+ *   target all of this is decided per TRIANGLE: a shape touching or resting
+ *   in one triangle of a mesh is still stopped by another one ahead of it.
  * @returns {boolean}
  */
 export function shape_cast(system, ray, shape, rotation, result, filter = returnTrue, skip_initial_overlaps = false) {
+    assert.ok(!shape_cast_running, NESTED_SHAPE_CAST);
+
+    shape_cast_running = true;
+    try {
+        return shape_cast_nearest(system, ray, shape, rotation, result, filter, skip_initial_overlaps);
+    } finally {
+        // also on the way out of a throw — a filter's own error, or the assert
+        // above in a cast the filter started — so the next cast is not refused
+        shape_cast_running = false;
+    }
+}
+
+const NONFINITE_DIRECTION = 'shape_cast: ray direction must be a unit vector, and this one has a component that is not finite';
+
+/**
+ * {@link shape_cast}, unguarded.
+ *
+ * @param {PhysicsSystem} system
+ * @param {{origin_x:number,origin_y:number,origin_z:number,direction_x:number,direction_y:number,direction_z:number,tMax:number}} ray
+ * @param {AbstractShape3D} shape
+ * @param {ArrayLike<number>} rotation
+ * @param {PhysicsSurfacePoint} result
+ * @param {(entity:number, collider:Collider, body_id:number)=>boolean} filter
+ * @param {boolean} skip_initial_overlaps
+ * @returns {boolean}
+ */
+function shape_cast_nearest(system, ray, shape, rotation, result, filter, skip_initial_overlaps) {
     const ox = ray.origin_x;
     const oy = ray.origin_y;
     const oz = ray.origin_z;
@@ -331,6 +2043,13 @@ export function shape_cast(system, ray, shape, rotation, result, filter = return
     assert.ok(Number.isFinite(tMax) && tMax > 0,
         `shape_cast: ray.tMax must be a positive finite sweep length, got ${tMax}`);
     if (!(tMax > 0) || !Number.isFinite(tMax)) return false;
+    // Nor a direction with a component that is not finite: there is no unit
+    // length to sweep by, and the swept AABB is unbounded — over a heightmap
+    // too big for one enumeration, the piece walk shortened an infinite piece
+    // forever. The same as the reach: loud in dev, a miss in prod.
+    const direction_finite = Number.isFinite(dx) && Number.isFinite(dy) && Number.isFinite(dz);
+    assert.ok(direction_finite, NONFINITE_DIRECTION);
+    if (!direction_finite) return false;
 
     const rx = rotation[0], ry = rotation[1], rz = rotation[2], rw = rotation[3];
 
@@ -373,24 +2092,58 @@ export function shape_cast(system, ray, shape, rotation, result, filter = return
     }
     if (n_total === 0) return false;
 
-    // ── 3. Narrowphase: per-candidate bisection ────────────────────
+    // ── 3. Narrowphase: per-candidate advancement ──────────────────
     //
     // Re-bind the swept shape's PosedShape3D once for shape + rotation;
-    // we update `px/py/pz` per bisection midpoint without rerunning
-    // setup (px/py/pz are public fields by contract).
+    // we update `px/py/pz` per sample pose without rerunning setup
+    // (px/py/pz are public fields by contract).
     swept_posed.shape = shape;
     swept_posed.qx = rx; swept_posed.qy = ry; swept_posed.qz = rz; swept_posed.qw = rw;
 
     let best_t = tMax;
+    /** When the winner's contact begins, which candidates are ranked by ({@link cast_touch_t}). */
+    let best_contact = tMax;
+    /** Whether the winner is a triangle face contact, which wins a tie ({@link SIMULTANEOUS}). */
+    let best_is_face = false;
     let best_body_id = -1;
     let best_entity = -1;
-    /** Winning collider and the transform it was posed at, for the normal probe. */
+    /** The struck collider's own entity, and the struck triangle of a concave one (else -1). */
+    let best_collider_entity = -1;
+    let best_triangle = -1;
+    /**
+     * Winning convex collider, for the normal probe — null when the winner is
+     * a triangle of a concave collider, kept in {@link best_triangle_local}.
+     */
     let best_collider = null;
+    /** The transform the winner was posed at (a triangle's: its collider's). */
     let best_tr = null;
+    /** Whether the winner came with its contact normal, in {@link best_normal}. */
+    let best_has_normal = false;
+
+    const stop_width = TOI_TOLERANCE * tMax;
+
+    // Fresh stamp for this query; wrap back to a cleared table before the
+    // counter could collide with a stamp left behind by an older query.
+    seen_stamp++;
+    if (seen_stamp >= 0x7FFFFFFF) {
+        scratch_seen.fill(0);
+        seen_stamp = 1;
+    }
 
     candidates: for (let i = 0; i < n_total; i++) {
         const body_id = scratch_candidates[i];
         const body_idx = body_id_index(body_id);
+
+        if (body_idx >= scratch_seen.length) {
+            // Preserve the stamps already written this query.
+            const grown = new Int32Array(Math.max(body_idx + 1, scratch_seen.length * 2));
+            grown.set(scratch_seen);
+            scratch_seen = grown;
+        }
+        // A second leaf of a body already tested: every collider of it was.
+        if (scratch_seen[body_idx] === seen_stamp) continue;
+        scratch_seen[body_idx] = seen_stamp;
+
         const entity = system.entityOf(body_id);
         if (entity < 0) continue;
 
@@ -405,193 +2158,216 @@ export function shape_cast(system, ray, shape, rotation, result, filter = return
             if (!filter(entity, collider, body_id)) continue;
 
             const target_tr = colliders[ci].transform;
-            candidate_posed.setup_components(
+
+            if (collider.shape.is_convex !== false) {
+                candidate_is_triangle = false;
+                candidate_posed.setup_components(
                     collider.shape,
                     target_tr.translation_x, target_tr.translation_y, target_tr.translation_z,
                     target_tr.rotation_x, target_tr.rotation_y, target_tr.rotation_z, target_tr.rotation_w
                 );
 
-            // Already overlapping at t = 0? The bisection's "no overlap at lo,
-            // overlap at hi" invariant doesn't hold for this candidate. Under CCD
-            // semantics it is a resting contact to step over — skip THIS candidate
-            // only, and keep scanning for real blockers.
-            //
-            // Under kinematic semantics targets are SOLID: a shape that starts
-            // genuinely inside one is blocked where it stands, `t = 0`, whatever
-            // direction it is trying to sweep. Nothing can beat that, so stop
-            // scanning. Getting out is depenetration's job, not the sweep's.
-            //
-            // Exact TANGENCY is the exception, and it needs one. A zero-depth
-            // touch is not "inside" anything — the shape is resting against a
-            // face, or flush with a brush seam, and is free to slide along it or
-            // leave. It also survives depenetration, which has no depth to push
-            // out of, so it persists frame after frame.
-            //
-            // Reporting it as a `t = 0` hit ends the scan, and that is the whole
-            // problem: the caller is handed a contact it correctly judges harmless
-            // for this direction and concludes the sweep is clear, while the body
-            // it was actually about to hit was never tested. A character flush
-            // against a wall falls through the floor that way. So a tangency
-            // blocks only when the sweep drives INTO it, and otherwise steps aside
-            // and lets the scan continue.
-            //
-            // MPR's depth at the START pose is what separates the two: positive
-            // means genuine overlap, none means tangency. Tangency is also exactly
-            // where the normal is hardest to recover, hence the second probe; if
-            // even that degenerates there is no normal to judge with and the
-            // contact blocks, stopping short being the safe failure.
-            swept_posed.px = ox; swept_posed.py = oy; swept_posed.pz = oz;
-            if (gjk(simplex_buf, swept_posed, candidate_posed)) {
-                if (skip_initial_overlaps) continue;
-
-                // The tangency exception reads MPR's depth and normal, both of
-                // which assume a convex target. This query has never supported
-                // concave ones (`overlap_shape` decomposes them per-triangle;
-                // nothing here does), so rather than extend a convex-only
-                // inference to geometry the module cannot see properly, leave
-                // those on the unconditional "solid, blocked at t = 0" path.
-                const convex_target = collider.shape.is_convex !== false;
-                if (convex_target && !probe_contact_normal(probe_normal, ox, oy, oz, target_tr)) {
-                    const known = recover_contact_normal(
-                        probe_normal, ox, oy, oz, dx, dy, dz, target_tr,
-                    );
-                    if (known) {
-                        // Both vectors are unit, so this is the sine of the angle
-                        // between the sweep and the contact plane. Zero means
-                        // exactly parallel — sliding along the face — and positive
-                        // means leaving it; neither blocks. The tolerance matters
-                        // because the parallel case sits right on the sign change,
-                        // and an MPR-recovered normal carries ~1e-6 of angular
-                        // noise: without it a sweep ALONG a face flips to
-                        // "head-on" on solver noise alone.
-                        const into = dx * probe_normal[0] + dy * probe_normal[1] + dz * probe_normal[2];
-                        if (into > -GRAZING_SINE_EPSILON) continue;
-                    }
-                }
+                const t = cast_candidate(
+                    ox, oy, oz, dx, dy, dz, best_contact, stop_width, skip_initial_overlaps,
+                    -Infinity, Infinity
+                );
+                if (t === CAST_MISS) continue;
+                if (t !== CAST_BLOCKED && !(cast_touch_t < (best_is_face ? best_contact - SIMULTANEOUS : best_contact))) continue;
 
-                best_t = 0;
+                best_contact = cast_touch_t;
+                best_is_face = false;
                 best_body_id = body_id;
                 best_entity = entity;
+                best_collider_entity = colliders[ci].entity;
+                best_triangle = -1;
                 best_collider = collider;
                 best_tr = target_tr;
-                break candidates;
+                best_has_normal = cast_has_normal;
+                if (cast_has_normal) best_normal.set(cast_normal);
+                if (t === CAST_BLOCKED) {
+                    best_t = 0;
+                    break candidates;
+                }
+                best_t = t;
+                continue;
             }
 
-            // ── Slab intersection: narrow the search interval analytically ─
+            // ── Concave collider: sweep its triangles ──────────────────
             //
-            // Compute the body's tight world AABB and intersect it with the
-            // swept shape's AABB sliding along the sweep direction. The
-            // result is the t-interval `[t_aabb_enter, t_aabb_exit]` during
-            // which the two AABBs overlap. Outside this interval the actual
-            // shapes can't overlap either (AABB is a superset of the
-            // shape), so we get to skip all of [0, t_aabb_enter) and
-            // (t_aabb_exit, best_t] without testing.
+            // A mesh or a heightmap is a SURFACE. Its convex hull — what the
+            // whole-shape GJK above would test — reports hits in the empty
+            // space between parts of one mesh and blocks a shape standing
+            // anywhere inside it, and a heightmap has no support function to
+            // build a hull from at all. So it is swept as the triangles under
+            // the swept AABB, enumerated in its own frame by the same
+            // decomposition the narrowphase and `overlap_shape` use, each one a
+            // candidate in its own right.
             //
-            // This is the key to making `shapeCast` scale to long sweeps:
-            // a 1 km cast of a 1 m sphere against another 1 m sphere has an
-            // AABB-overlap window of ≈ 2 m (the sum of diameters along the
-            // sweep axis), reducing the coarse-step grid from a 30 m
-            // resolution (1000/32) to 6 cm (2/32).
-            collider.shape.compute_bounding_box(target_local_aabb);
-            aabb3_transform_oriented(
-                target_world_aabb, 0,
-                target_local_aabb[0], target_local_aabb[1], target_local_aabb[2],
-                target_local_aabb[3], target_local_aabb[4], target_local_aabb[5],
-                target_tr.translation_x, target_tr.translation_y, target_tr.translation_z,
-                target_tr.rotation_x, target_tr.rotation_y, target_tr.rotation_z, target_tr.rotation_w
+            // At most MAX_TRIANGLES_PER_PAIR of them at a time: a sweep whose box
+            // takes in more is walked in pieces, in sweep order, each tested
+            // only for contacts that begin within it — a later contact on one
+            // of its triangles is the next piece's to find, with the triangles
+            // around it — until one is hit.
+            //
+            // A mesh or heightmap a rigid TransformedShape3D wraps is that
+            // surface at the composed pose, as the narrowphase collides it. A
+            // wrapper that scales is not unwrapped, and has no enumerator, here
+            // as there.
+            let concave = collider.shape;
+            let concave_tr = target_tr;
+            while (concave.isTransformedShape3D === true && rigid_subject_pose(
+                subject_pose, concave,
+                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
+            )) {
+                concave = concave.subject;
+                concave_tr = subject_pose;
+            }
+
+            // The sweep in the surface's frame, for the per-triangle plane
+            // test in `load_triangle`.
+            const qx = concave_tr.rotation_x, qy = concave_tr.rotation_y, qz = concave_tr.rotation_z, qw = concave_tr.rotation_w;
+            v3_quaternion_apply_inverse(
+                local_sweep, 0,
+                ox - concave_tr.translation_x, oy - concave_tr.translation_y, oz - concave_tr.translation_z,
+                qx, qy, qz, qw
             );
+            v3_quaternion_apply_inverse(local_sweep, 3, dx, dy, dz, qx, qy, qz, qw);
+            const lx = local_sweep[0], ly = local_sweep[1], lz = local_sweep[2];
+            const ldx = local_sweep[3], ldy = local_sweep[4], ldz = local_sweep[5];
 
-            let t_aabb_enter = -Infinity;
-            let t_aabb_exit = Infinity;
-            let skip_candidate = false;
-            for (let ax = 0; ax < 3; ax++) {
-                const init_min = initial_aabb[ax];
-                const init_max = initial_aabb[ax + 3];
-                const body_min = target_world_aabb[ax];
-                const body_max = target_world_aabb[ax + 3];
-                const d_ax = ax === 0 ? dx : (ax === 1 ? dy : dz);
-                if (d_ax === 0) {
-                    // Static along this axis: AABBs must overlap in their
-                    // initial position or this candidate is unreachable.
-                    if (init_max < body_min || init_min > body_max) {
-                        skip_candidate = true;
-                        break;
+            // The walk ends. Every piece is at least `min_piece` long, but the
+            // last: one that reaches the end of the sweep, or one that cannot
+            // be made to fit even that short — the shape's own box holds more
+            // than the budget — which takes the rest of the sweep with it,
+            // tested as far as the budget goes. So there are at most
+            // 1 / MIN_PIECE_FRACTION + 1 pieces, and every shortening of one
+            // takes at least a tenth off it until it is `min_piece` long.
+            // Offered ever-shorter pieces instead, a sphere whose own box held
+            // 0.81 of the budget walked a Zeno walk that never reached the end
+            // of a 2 m slide.
+            const min_piece = MIN_PIECE_FRACTION * tMax;
+            let piece_start = 0;
+            let piece_end = best_contact;
+            let last_piece = false;
+            while (piece_start < best_contact) {
+                let tri_count = count_triangles(concave, concave_tr, sweep_piece_aabb(dx, dy, dz, piece_start, piece_end));
+                while (tri_count > MAX_TRIANGLES_PER_PAIR && !last_piece) {
+                    const length = piece_end - piece_start;
+                    if (length > min_piece) {
+                        // the box's triangles grow with its area, about the square of its length
+                        const shorter = length * Math.sqrt(MAX_TRIANGLES_PER_PAIR / tri_count) * 0.9;
+                        piece_end = piece_start + (shorter > min_piece ? shorter : min_piece);
+                    } else {
+                        last_piece = true;
+                        piece_end = best_contact;
                     }
-                    continue;
+                    tri_count = count_triangles(concave, concave_tr, sweep_piece_aabb(dx, dy, dz, piece_start, piece_end));
                 }
-                // swept_min(t) = init_min + d·t, swept_max(t) = init_max + d·t.
-                // Slab-enter: swept_max(t) = body_min  →  t = (body_min − init_max) / d
-                // Slab-exit:  swept_min(t) = body_max  →  t = (body_max − init_min) / d
-                const t1 = (body_min - init_max) / d_ax;
-                const t2 = (body_max - init_min) / d_ax;
-                const lo = t1 < t2 ? t1 : t2;
-                const hi = t1 < t2 ? t2 : t1;
-                if (lo > t_aabb_enter) t_aabb_enter = lo;
-                if (hi < t_aabb_exit)  t_aabb_exit  = hi;
-            }
-            if (skip_candidate) continue;
-            if (t_aabb_enter > t_aabb_exit) continue;
-
-            // Clamp to the relevant t-window: [0, best_t]. Anything beyond
-            // best_t can't tighten the answer.
-            const t_start = t_aabb_enter > 0     ? t_aabb_enter : 0;
-            const t_end   = t_aabb_exit  < best_t ? t_aabb_exit  : best_t;
-            if (t_start >= t_end) continue;
-
-            // Coarse-search within the narrowed interval to find any t for
-            // which the shapes overlap (their AABBs do by construction; the
-            // shapes themselves may not, e.g. two spheres passing alongside).
-            const step_dt = (t_end - t_start) / COARSE_STEPS;
-            let t_prev = t_start;
-            let t_hi = -1;
-            for (let s = 1; s <= COARSE_STEPS; s++) {
-                const t = t_start + s * step_dt;
-                swept_posed.px = ox + dx * t;
-                swept_posed.py = oy + dy * t;
-                swept_posed.pz = oz + dz * t;
-                if (gjk(simplex_buf, swept_posed, candidate_posed)) {
-                    t_hi = t;
-                    break;
+                // A heightmap's piece was only counted: enumerate the one settled on, once.
+                if (concave.isHeightMapShape3D === true) {
+                    tri_count = enumerate_triangles(concave, concave_tr, piece_aabb);
                 }
-                t_prev = t;
-            }
-            if (t_hi < 0) continue;
-
-            // Bisect [t_prev, t_hi]: invariant is `gjk(t_lo) === false` and
-            // `gjk(t_hi) === true`.
-            let t_lo = t_prev;
-            const stop_width = TOI_TOLERANCE * tMax;
-            for (let bi = 0; bi < MAX_BISECTION && (t_hi - t_lo) > stop_width; bi++) {
-                const t_mid = (t_lo + t_hi) * 0.5;
-                swept_posed.px = ox + dx * t_mid;
-                swept_posed.py = oy + dy * t_mid;
-                swept_posed.pz = oz + dz * t_mid;
-                if (gjk(simplex_buf, swept_posed, candidate_posed)) {
-                    t_hi = t_mid;
-                } else {
-                    t_lo = t_mid;
+                if (tri_count > MAX_TRIANGLES_PER_PAIR) {
+                    if (!triangle_overflow_reported) {
+                        triangle_overflow_reported = true;
+                        console.warn(
+                            `shape_cast: the sweep's box overlaps ${tri_count} triangles of a`
+                            + ` ${concave.constructor.name} over a stretch too short to split;`
+                            + ` it is tested against ${MAX_TRIANGLES_PER_PAIR} and not the rest.`
+                        );
+                    }
+                    tri_count = MAX_TRIANGLES_PER_PAIR;
                 }
-            }
 
-            // Use t_lo (the just-SEPARATING side of the bisection) rather
-            // than t_hi (just-overlapping). With the fixed GJK that no
-            // longer flags 5 mm-clear gaps as overlap, the bisection is
-            // tight; reporting t_lo gives kinematic callers a conservative
-            // TOI — the swept shape at the reported moment is provably NOT
-            // overlapping the target. The normal-probe below steps a few
-            // mm past best_t to get a valid simplex for MPR.
-            if (t_lo < best_t) {
-                best_t = t_lo;
-                best_body_id = body_id;
-                best_entity = entity;
-                best_collider = collider;
-                best_tr = target_tr;
+                triangle_count = tri_count;
+                for (let k = 0; k < tri_count; k++) {
+                    triangle_offset = k * TRIANGLE_FLOAT_STRIDE;
+                    load_triangle(
+                        concave, triangle_buffer, triangle_offset, concave_tr,
+                        lx, ly, lz, ldx, ldy, ldz,
+                        ox, oy, oz, tMax, skip_initial_overlaps
+                    );
+
+                    // a face may still win a tie with a contact of another kind
+                    let reach = best_is_face ? best_contact : best_contact + SIMULTANEOUS;
+                    if (reach > tMax) reach = tMax;
+                    const limit = reach < piece_end ? reach : piece_end;
+                    const t = cast_candidate(
+                        ox, oy, oz, dx, dy, dz, limit, stop_width, skip_initial_overlaps,
+                        triangle_window_enter, triangle_window_exit
+                    );
+                    if (t === CAST_MISS) continue;
+                    const beats = t === CAST_BLOCKED || (cast_face
+                        ? cast_touch_t < limit
+                        : cast_touch_t < (best_is_face ? best_contact - SIMULTANEOUS : best_contact) && cast_touch_t < piece_end);
+                    if (!beats) continue;
+
+                    best_contact = cast_touch_t;
+                    best_is_face = cast_face;
+                    best_body_id = body_id;
+                    best_entity = entity;
+                    best_collider_entity = colliders[ci].entity;
+                    // the enumerators' feature id is the triangle's index plus one
+                    best_triangle = triangle_buffer[triangle_offset + TRIANGLE_FEATURE_ID_OFFSET] - 1;
+                    best_collider = null;
+                    if (concave_tr === subject_pose) {
+                        best_subject_pose.copy(subject_pose);
+                        best_tr = best_subject_pose;
+                    } else {
+                        best_tr = concave_tr;
+                    }
+                    best_triangle_local.set(triangle_local);
+                    if (cast_face) {
+                        best_has_normal = true;
+                        best_normal.set(plane_normal);
+                    } else {
+                        best_has_normal = cast_has_normal;
+                        if (cast_has_normal) best_normal.set(cast_normal);
+                    }
+                    if (t === CAST_BLOCKED) {
+                        best_t = 0;
+                        break candidates;
+                    }
+                    best_t = t;
+                }
+
+                // A hit in this piece is nearer than anything a later one holds.
+                if (best_contact < piece_end || last_piece) break;
+
+                // Offer the next piece the length this one's triangles say fills
+                // the budget — never less than this one's — not the rest of the
+                // sweep: enumerating the rest, over-full, only to learn that it
+                // was, took a third of a 2.6 m sweep's time over a
+                // 720,000-triangle floor.
+                const piece_length = piece_end - piece_start;
+                const fill = Math.sqrt(MAX_TRIANGLES_PER_PAIR / (tri_count > 0 ? tri_count : 1)) * 0.9;
+                piece_start = piece_end;
+                piece_end = piece_start + (fill > 1 ? piece_length * fill : piece_length);
+                if (!(piece_end < best_contact)) piece_end = best_contact;
             }
         }
     }
 
     if (best_body_id === -1) return false;
 
+    // What was struck — a convex collider, or the one triangle of a concave
+    // one — posed for {@link shape_cast_struck_support}.
+    if (best_collider !== null) {
+        struck_posed.setup_components(
+            best_collider.shape,
+            best_tr.translation_x, best_tr.translation_y, best_tr.translation_z,
+            best_tr.rotation_x, best_tr.rotation_y, best_tr.rotation_z, best_tr.rotation_w
+        );
+    } else {
+        struck_triangle_vertices.set(best_triangle_local);
+        struck_posed.setup_components(
+            struck_triangle_shape,
+            best_tr.translation_x, best_tr.translation_y, best_tr.translation_z,
+            best_tr.rotation_x, best_tr.rotation_y, best_tr.rotation_z, best_tr.rotation_w
+        );
+    }
+
     const rp = result.position;
     const rn = result.normal;
 
@@ -603,20 +2379,26 @@ export function shape_cast(system, ray, shape, rotation, result, filter = return
     rp[1] = swept_y;
     rp[2] = swept_z;
 
-    // ── Contact-normal recovery via MPR ────────────────────────────
+    // ── Contact normal ─────────────────────────────────────────────
     //
-    // Bisection converges with `swept_posed` somewhere within
-    // `stop_width = TOI_TOLERANCE * tMax` of the true contact. At
-    // exactly `best_t` the overlap depth is therefore sub-millimetre
-    // on practical sweeps. EPA on smooth-vs-smooth supports at this
-    // overlap can't tighten before its iteration cap and returns a
-    // direction off by ~30° from truth. MPR is the better tool here:
-    // it converges in 5-15 iterations on smooth surfaces, same MTV
-    // output convention as EPA (direction = A's interior into B,
-    // magnitude = depth).
+    // A hit found by advancement comes with its normal: the direction
+    // separating the two at the reported pose, from the closest points the
+    // distance kernel stopped on — exact for any pair of shapes, edge and
+    // corner contacts included. A triangle FACE contact comes with the face's.
+    // Read by penetration instead, off the one triangle that won, it leans
+    // toward that triangle's edge when the contact sits near the seam of a
+    // face split into triangles — a capsule striking a cube face across its
+    // diagonal read 5.7°, where a convex box reads its face exactly.
+    //
+    // The rest — a hit blocked at the start, or one the bracket search found
+    // — is read off by MPR. EPA on smooth-vs-smooth supports at this overlap
+    // can't tighten before its iteration cap and returns a direction off by
+    // ~30° from truth. MPR is the better tool here: it converges in 5-15
+    // iterations on smooth surfaces, same MTV output convention as EPA
+    // (direction = A's interior into B, magnitude = depth).
     //
     // The probe pose is `NORMAL_PROBE_OFFSET` past `best_t` along the sweep
-    // (a few mm into the target) — bisection stops on the just-SEPARATING
+    // (a few mm into the target) — the search stops on the just-SEPARATING
     // side, so there is no MTV to read exactly at `best_t`. The reported
     // `result.t` stays at `best_t`; only the normal probe moves.
     // `recover_contact_normal` handles the grazing case, where advancing
@@ -625,17 +2407,32 @@ export function shape_cast(system, ray, shape, rotation, result, filter = return
     const contact_y = oy + dy * best_t;
     const contact_z = oz + dz * best_t;
     let normal_x = -dx, normal_y = -dy, normal_z = -dz;
+    result.collider_entity = best_collider_entity;
+    result.triangle = best_triangle;
+    if (best_has_normal) {
+        rn[0] = best_normal[0]; rn[1] = best_normal[1]; rn[2] = best_normal[2];
+        result.t = best_t;
+        result.entity = best_entity;
+        result.body_id = best_body_id;
+        return true;
+    }
     if (best_collider !== null) {
+        candidate_is_triangle = false;
         candidate_posed.setup_components(
-                best_collider.shape,
-                best_tr.translation_x, best_tr.translation_y, best_tr.translation_z,
-                best_tr.rotation_x, best_tr.rotation_y, best_tr.rotation_z, best_tr.rotation_w
-            );
-        if (recover_contact_normal(probe_normal, contact_x, contact_y, contact_z, dx, dy, dz, best_tr)) {
-            normal_x = probe_normal[0];
-            normal_y = probe_normal[1];
-            normal_z = probe_normal[2];
-        }
+            best_collider.shape,
+            best_tr.translation_x, best_tr.translation_y, best_tr.translation_z,
+            best_tr.rotation_x, best_tr.rotation_y, best_tr.rotation_z, best_tr.rotation_w
+        );
+    } else {
+        // The probes re-anchor the triangle themselves.
+        triangle_local.set(best_triangle_local);
+        triangle_tr = best_tr;
+        candidate_is_triangle = true;
+    }
+    if (recover_contact_normal(probe_normal, contact_x, contact_y, contact_z, dx, dy, dz)) {
+        normal_x = probe_normal[0];
+        normal_y = probe_normal[1];
+        normal_z = probe_normal[2];
     }
 
     rn[0] = normal_x; rn[1] = normal_y; rn[2] = normal_z;
@@ -644,3 +2441,22 @@ export function shape_cast(system, ray, shape, rotation, result, filter = return
     result.body_id = best_body_id;
     return true;
 }
+
+/**
+ * Support point, in world space, of what the last successful {@link shape_cast}
+ * struck — the convex collider, or for a concave collider the one triangle the
+ * hit was on — along the world direction in `direction[direction_offset .. +2]`, under
+ * {@link AbstractShape3D#support}'s contract.
+ *
+ * For a caller that needs the struck surface's own geometry at the contact
+ * (the CCD pass places its impulse where the two facing features overlap).
+ * Valid until the next cast; meaningless before any cast has hit.
+ *
+ * @param {Float64Array} out receives the point
+ * @param {number} out_offset
+ * @param {Float64Array|number[]} direction
+ * @param {number} direction_offset
+ */
+export function shape_cast_struck_support(out, out_offset, direction, direction_offset) {
+    struck_posed.support(out, out_offset, direction, direction_offset);
+}