Reach the last testable corners of the collision code

Five branches of _ibc.py had no coverage, and each turned out to be the mirror
image of a covered one, told apart only by a choice the caller never makes
deliberately. So each is pinned as an invariance rather than a value.

The 3D slider names the edge an agent leaves by its position in the triangle --
Q0Q1, Q1Q2 or Q2Q0 -- and branches on which. Every 3D case in the suite writes
the shared edge first, so the middle branch was unreachable by construction.
Cyclically rolling one triangle's vertices walks all three in turn, and the
resolved position is bit-identical across them, which is the actual contract:
where a vertex list starts is an accident of the mesh file. Rotation rather than
an arbitrary permutation, so the winding and hence the normal are preserved.

The moving slider has the same shape twice over. Which of an adjacent element's
two vertices is the shared one decides a branch, so the wedged-agent case now
runs both orderings and compares them directly -- the only way to see the two
disagree. That case also leaves its element by the second vertex rather than the
first, which nothing else in the moving suite did.

The travel-reversal critical time only binds when the element turns through the
perpendicular to the agent's travel, which no translating or tilting wall does;
a pivot from 60 to 120 degrees flips the projection from +2 to -2. The test
asserts that sign change, so it cannot quietly stop exercising the branch.

Contact arriving at the very end of the step is covered too, where the slider
skips the projection entirely and only backs the agent off.

The moving stack-exhaustion re-raise gets its own case: it is a different
routine from the static one, so covering that said nothing about this. It does
not exhaust the real stack -- every element the moving slider crosses costs an
ODE solve, so doing that naturally took about three seconds. The limit is
lowered relative to the depth already in use instead, which runs in 0.27s and
does not depend on the platform's stack size. RecursionError subclasses
RuntimeError, so the explained failure is told from a bare one by inspecting it
rather than by the except clause.

Also fixes a typo in a raise the tests cannot reach: Brenq -> Brentq.

Coverage of _ibc.py goes from 96% to 99%. The seven lines left are three
placeholders behind the 3D-moving NotImplementedError, two numerical corners
documented in place as unreachable, and two solver non-convergence raises.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: mountaindust

planktos/_ibc.py

@@ -1241,7 +1241,7 @@ def x_DE(t,x):
         sol = optimize.root_scalar(spd_diff, method='brentq', bracket=(t_I,t_end))
 
         if not sol.converged:
-            raise RuntimeError("Brenq did not converge.")
+            raise RuntimeError("Brentq did not converge.")
         t_rot = sol.root
         # for debugging
         # print(f't_rot = {t_rot}')

tests/test_collisions_junctions.py

@@ -36,6 +36,7 @@
 in space or on the units it is expressed in.
 '''
 
+import sys
 import warnings
 
 import numpy as np
@@ -489,6 +490,58 @@ def test_stack_exhaustion_message_quantifies_the_mismatch():
     assert 'elements in one step' in msg
 
 
+def _stack_depth():
+    '''Frames currently on the stack. Cheaper than inspect.stack(), which builds
+    a full record per frame.'''
+    depth, frame = 0, sys._getframe()
+    while frame is not None:
+        depth += 1
+        frame = frame.f_back
+    return depth
+
+
+def test_moving_slide_exhausting_the_stack_reports_the_cause():
+    '''The moving slider has its own re-raise, and needs its own case: a slide
+    along a deforming mesh recurses through a different routine than the static
+    one, so covering one says nothing about the other.
+
+    The interpreter's real stack is not exhausted here. Every element the moving
+    slider crosses costs an ODE solve, so running it out naturally takes seconds;
+    the limit is lowered relative to the depth already in use instead. What is
+    under test is the re-raise, not how many frames the interpreter starts with,
+    and pinning it to a relative depth keeps the test independent of the platform
+    stack size.
+    '''
+    # ~270 elements across the slide, comfortably more than the depth allowed
+    start_mesh = h.wall_segments(300, 5.0, y_lo=0.0, y_hi=1.0)
+    end_mesh = h.wall_segments(300, 5.02, y_lo=0.0, y_hi=1.0)
+    start = np.array([4.995, 0.05])
+    end = np.array([5.1, 0.95])
+
+    original = sys.getrecursionlimit()
+    sys.setrecursionlimit(_stack_depth() + 100)
+    try:
+        h.call_moving(start, end, start_mesh, end_mesh)
+        raised = None
+    except RuntimeError as err:
+        # RecursionError subclasses RuntimeError, so this catches both the
+        # explained failure and a bare one leaking through; they are told apart
+        # below rather than by the except clause.
+        raised = err
+    finally:
+        sys.setrecursionlimit(original)
+
+    assert raised is not None, 'the slide should have run out of stack'
+    assert not isinstance(raised, RecursionError), \
+        f'bare RecursionError escaped instead of being explained: {raised}'
+    msg = str(raised)
+    assert 'sliding an agent' in msg, f'should name what ran out; got: {msg}'
+    assert 'dt' in msg, f'should say what to change; got: {msg}'
+    assert 'setrecursionlimit' in msg, f'should offer the escape hatch: {msg}'
+    assert isinstance(raised.__cause__, RecursionError), \
+        'the original RecursionError should be chained as the cause'
+
+
 # --------------------------------------------------------------------------- #
 #                 general sanity checks, any geometry                         #
 # --------------------------------------------------------------------------- #

tests/test_collisions_moving.py

@@ -356,6 +356,123 @@ def test_release_from_a_turning_obstacle_keeps_the_agent_outside():
     h.assert_displacement_bounded_moving(start, end, newend, m0, m1)
 
 
+# --------------------------------------------------------------------------- #
+#             contact arriving at the very end of the step                    #
+# --------------------------------------------------------------------------- #
+
+def test_contact_at_the_very_end_of_the_step_just_backs_off():
+    '''With essentially none of the step left to slide through, the slider skips
+    the whole projection and simply places the agent off the boundary it just
+    reached. Worth its own case because that shortcut returns before any of the
+    machinery the other tests exercise.
+
+    A wall rising from y=0 to y=0.1 and an agent dropping from y=0.5 to a hair
+    under y=0.1 meet at t = 0.5/(0.5+1e-9), which is 1 to within 2e-9.
+    '''
+    start_mesh = h.segment((0.0, 0.0), (1.0, 0.0))
+    end_mesh = h.segment((0.0, 0.1), (1.0, 0.1))
+    start = np.array([0.5, 0.5])
+    end = np.array([0.5, 0.1 - 1e-9])
+
+    newend, dx, idx = h.call_moving(start, end, start_mesh, end_mesh, 'sliding')
+
+    assert idx == 0, 'expected contact with the rising wall'
+    assert np.allclose(newend, [0.5, 0.1], atol=POS_ATOL), \
+        f'expected the agent left at the contact point (0.5,0.1), got {newend}'
+    assert newend[1] >= 0.1, 'agent was left below the wall it just met'
+
+
+# --------------------------------------------------------------------------- #
+#              the travel reversal as the binding critical time               #
+# --------------------------------------------------------------------------- #
+# The slider re-checks two critical times when an agent is still on its element
+# at the end of the step: the element's shortest moment, and where the agent's
+# direction of travel along it reverses. The reversal is the binding one when it
+# comes first, which needs the element to turn through the perpendicular to the
+# agent's travel -- something no translating or gently tilting wall does.
+
+def test_travel_reversal_can_be_the_binding_critical_time():
+    '''An element pivoting from 60 to 120 degrees while the agent travels
+    straight in +x. Its projection onto the agent's travel goes from +2 to -2,
+    so the direction of sliding reverses partway through the step.
+
+    There is no closed form for where the agent lands, so this asserts the
+    invariants plus equivariance. As with the release branch, the usual
+    no-penetration check does not apply to a lone pivoting element: it sweeps
+    across the agent's own start point.
+    '''
+    def pivot(degrees, length=2.0):
+        theta = np.radians(degrees)
+        offset = np.array([np.cos(theta), np.sin(theta)])*length/2
+        return np.array([[-offset, offset]])
+
+    m0, m1 = pivot(60), pivot(120)
+    start = np.array([-1.0, 0.5]); end = np.array([1.0, 0.5])
+    vec = end - start
+
+    # the reversal exists: the element's projection onto the travel flips sign
+    assert (np.dot(vec, m0[0, 1] - m0[0, 0]) *
+            np.dot(vec, m1[0, 1] - m1[0, 0])) < 0, \
+        'this element does not turn through the perpendicular to the travel'
+
+    newend, dx, idx = h.call_moving(start, end, m0, m1)
+
+    assert idx is not None, 'expected contact with the pivoting element'
+    h.assert_finite(newend, 'slide through a travel reversal')
+    h.assert_displacement_bounded_moving(start, end, newend, m0, m1)
+
+    T = h.rigid_2D(0.7, (3.0, -2.0))
+    moved, _, _ = h.call_moving(T(start), T(end), T(m0), T(m1))
+    assert np.allclose(np.asarray(moved, float), T(newend), atol=1e-5), \
+        f'rotated problem gave {np.asarray(moved)}, expected {T(newend)}'
+
+
+# --------------------------------------------------------------------------- #
+#           a wedged agent on a moving joint, either vertex order             #
+# --------------------------------------------------------------------------- #
+
+def test_moving_wedge_rides_the_joint_whatever_the_vertex_order():
+    '''An agent that slides into a moving joint it cannot advance past is left
+    at that joint and carried with it.
+
+    Which of the adjacent element's two vertices is the shared one is an
+    accident of how the mesh file was written, and the slider has a branch per
+    case. Both must give the same answer, so both are run here and compared:
+    that is the only way to see the two branches disagree.
+
+    The focal element is traversed left to right, so the agent leaves by its
+    *second* vertex -- the other of a similar pair of branches, and the one no
+    other moving case reaches.
+    '''
+    joint = np.array([5.0, 5.0])
+    shift = np.array([0.05, 0.0])
+    focal = h.segment((2.0, 5.0), tuple(joint))     # agent slides off its Q1
+    ramp_tip = (5.6, 7.5)                           # leans back over the focal
+    start = np.array([4.2, 6.4])                    # diving steeply into focal
+    end = np.array([5.2, 4.2])                      # overshooting the joint
+
+    results = {}
+    for label, ramp in (('joint first', h.segment(tuple(joint), ramp_tip)),
+                        ('joint second', h.segment(ramp_tip, tuple(joint)))):
+        m0 = np.concatenate([focal, ramp])
+        m1 = m0 + shift
+        newend, dx, idx = h.call_moving(start, end, m0, m1)
+        h.assert_finite(newend, f'moving wedge ({label})')
+        # wedged at the joint, which has itself moved with the mesh
+        assert np.allclose(newend, joint + shift, atol=POS_ATOL), \
+            f'{label}: expected the agent at the joint {joint+shift}, got {newend}'
+        # backed off it, not sitting exactly on it
+        offset = float(np.linalg.norm(newend - (joint + shift)))
+        assert 0 < offset < POS_ATOL, \
+            f'{label}: agent left {offset:.3e} from the vertex'
+        results[label] = newend
+
+    assert np.allclose(results['joint first'], results['joint second'],
+                       atol=1e-12), \
+        ('the resolved position changed with the order the adjacent element\'s '
+         f'vertices were stored: {results}')
+
+
 # --------------------------------------------------------------------------- #
 #       golden multi-step trajectory (drift detector for moving collisions)    #
 # --------------------------------------------------------------------------- #

tests/test_collisions_static_3d.py

@@ -158,6 +158,34 @@ def test_coplanar_tiled_surface_slides_across_internal_edge():
     assert np.allclose(newend[:2], [1.0, 3.0], atol=POS_ATOL)   # slid to slide_pt in t2
 
 
+@pytest.mark.parametrize('roll', [0, 1, 2])
+def test_slide_across_internal_edge_ignores_vertex_rotation(roll):
+    '''Where a triangle's vertices start in its stored list is arbitrary -- a
+    mesh file may list any of the three first -- so rotating them must not move
+    the agent.
+
+    It is worth checking because the slider identifies the edge an agent leaves
+    by its position in the triangle (Q0Q1, Q1Q2 or Q2Q0) and takes a different
+    branch for each. Rolling the vertices walks all three: the same physical
+    edge is the first, second and third in turn. Rotation is used rather than an
+    arbitrary permutation because it preserves the winding, and so the normal.
+
+    Every other 3D case in the suite builds its triangles with the shared edge
+    written first, which is why the middle branch went unreached.
+    '''
+    t1 = np.array([[0., 0., 0.], [4., 0., 0.], [4., 4., 0.]])   # lower-right
+    t2 = np.array([[0., 0., 0.], [4., 4., 0.], [0., 4., 0.]])   # upper-left
+    start = np.array([3., 1., 0.3]); end = np.array([1., 3., -0.5])
+
+    mesh = np.array([np.roll(t1, roll, axis=0), t2])
+    newend, dx, idx = h.call_static(start, end, mesh, 'sliding')
+
+    assert newend[2] >= -POS_ATOL, "penetrated the flat surface"
+    assert newend[1] - newend[0] > 1.0, "stuck at the internal diagonal edge"
+    assert np.allclose(newend[:2], [1.0, 3.0], atol=POS_ATOL), \
+        f"vertex rotation {roll} moved the agent to {newend}"
+
+
 @pytest.mark.parametrize('slope', [0.05, 0.2, 0.5])
 def test_gentle_concave_fold_slides_onto_neighbor(slope):
     # A gentle concave valley (faces z = slope*|x|). An agent sliding down one