lbm: translating circles move with refill (S3a)

MovingCircleCells reclassifies swept-band cells from immutable old/new FP64
predicates: covered cells add their raw momentum and mass to diagnostics and
become solid; uncovered cells are refilled in all nine slots from donors
fluid in both geometries (mean density, NEQ from the best-aligned donor,
wall velocity at the cell), counting eq_only and no_donor. MovingCircleLinks
adds the translation velocity to the wall velocity. Simulation.run(1)
uploads the motion record, runs M1 then M2, synchronizes, rejects a nonzero
no_donor count and only then commits the target and uploads the hold
record; any failure marks the Simulation failed. Targets block direct
stepper calls and multi-step runs. get_flags reads device flags back when
translating circles exist. Contract section 10b.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

tests/unit/test_moving_bodies.py

@@ -217,20 +217,21 @@ def test_add_body_and_set_body_route_targets(monkeypatch):
     bid = sim.add_body("circle", (50., 40.), 10., translation=Translation((-2., 2., -3., 3.), .1))
     still = sim.add_body("circle", (100., 40.), 5.)
     motion = sim.bodies.get(bid).motion
-    assert sim.stepper.blocked is not None  # declaring a moving circle blocks direct steps
-    for initialized in (False, True):  # S2a: displacement disabled before and after initialize
-        sim._initialized = initialized
-        for kwargs in (dict(offset=(0., .3), vy=.05), dict(offset=(0., 0.)), dict(vy=.05),
-                       dict(vx=.05), dict(offset=(0., .1), omega=.01)):
-            with pytest.raises(ValueError, match="disabled until S3"):
-                sim.set_body(bid, **kwargs)
-            assert motion.pending is None and motion.applied == (0., 0.)
-    sim._initialized = False
+    sim._moving_tables = "tables"
+    sim._attach_moving()
+    assert sim.stepper.blocked is None
+    sim.set_body(bid, offset=(0., .3), vy=.05)
+    assert sim.stepper.blocked == module.PENDING_BLOCKED  # direct steps never consume a target
+    sim.set_body(bid, offset=(0., .4), vy=.05)  # last wins
+    for kwargs in (dict(offset=(0., .6)), dict(vy=.05), dict(vx=.05),
+                   dict(offset=(0., .1), vy=.2), dict(offset=(0., 0.), vy=.01)):
+        with pytest.raises(ValueError):
+            sim.set_body(bid, **kwargs)
+        assert motion.pending == ((0., .4), (0., .05))  # invalid input keeps the target
+    sim.set_body(bid, omega=.01)  # omega-only keeps the pending target
     obj = sim.bodies.get(bid)
-    assert obj.state.omega == 0.
-    sim.set_body(bid, omega=.01)  # spin on hold stays allowed
     assert obj.state.omega == .01 and (obj.state.vx, obj.state.vy) == (0., 0.)
-    assert motion.pending is None
+    assert motion.pending == ((0., .4), (0., .05)) and motion.applied == (0., 0.)
     with pytest.raises(ValueError, match="not declared"):
         sim.set_body(still, offset=(0., .1))
     sim.set_body(still, vx=.01)  # stationary API unchanged
@@ -243,6 +244,69 @@ def test_add_body_and_set_body_route_targets(monkeypatch):
                          **kwargs)
 
 
+class Tables:
+    """MovingTables double: records uploads, steps and diagnostics reads."""
+    DIAG = ("no_donor",)
+
+    def __init__(self, log, no_donor=0., fail=None):
+        self.log, self.no_donor, self.fail = log, no_donor, fail
+
+    def upload_records(self, circles, stream):
+        records = [m.record() for m, _ in circles]
+        self.log.append(("upload", records))
+        if self.fail == "upload":
+            raise RuntimeError("upload failed")
+        return any(r[0] != r[1] for r in records)
+
+    def zero_diagnostics(self, stream):
+        self.log.append("zero_diag")
+
+    def download_diagnostics(self):
+        return np.array([[self.no_donor]], np.float32)
+
+
+def advancing_simulation(monkeypatch, **tables):
+    sim, writes = moving_simulation(monkeypatch)
+    sim.bodies.objects[0].motion = circle()
+    sim.stepper = SimpleNamespace(
+        moving=Tables(writes, **tables), blocked=None,
+        _step=lambda n, advance=False, **k: writes.append(("step", n, advance)))
+    sim._moving_tables = sim.stepper.moving
+    return sim, writes, sim.bodies.objects[0].motion
+
+
+def test_run_one_advances_and_commits_after_sync(monkeypatch):
+    sim, writes, motion = advancing_simulation(monkeypatch)
+    motion.set_target((0., .25), (0., .05))
+    with pytest.raises(ValueError, match="run\\(1\\)"):  # multi-step with a target
+        sim.run(2, stream=STREAM)
+    assert writes == [] and motion.pending is not None
+    sim.run(0, stream=STREAM)  # zero steps never consume the target
+    assert motion.pending is not None
+    sim.run(1, stream=STREAM)
+    uploads = [w for w in writes if isinstance(w, tuple) and w[0] == "upload"]
+    assert uploads[0][1] == [((50., 40.), (50., 40.25), (0., .05))]
+    assert uploads[1][1] == [((50., 40.25), (50., 40.25), (0., 0.))]  # first hold after move
+    assert ("step", 1, True) in writes
+    assert motion.applied == (0., .25) and motion.pending is None
+    writes.clear()
+    sim.run(3, stream=STREAM)  # hold steps: no advance
+    assert ("step", 3, False) in writes and motion.applied == (0., .25)
+
+
+@pytest.mark.parametrize("failure", ("upload", "no_donor"))
+def test_failed_advance_commits_nothing_and_fails_simulation(monkeypatch, failure):
+    kwargs = dict(fail="upload") if failure == "upload" else dict(no_donor=1.)
+    sim, writes, motion = advancing_simulation(monkeypatch, **kwargs)
+    motion._on_failure = sim._fail_moving
+    motion.set_target((0., .25), (0., .05))
+    with pytest.raises(RuntimeError):
+        sim.run(1, stream=STREAM)
+    assert motion.applied == (0., 0.) and motion.failed and sim._failed is not None
+    with pytest.raises(RuntimeError, match="Simulation failed"):
+        sim.run(1, stream=STREAM)
+
+
 def test_moving_tables_layout_and_attachment(monkeypatch):
     from CelerisLab.body.motion import MovingTables
     a = MovingCircle((50., 40.), 10., Translation((-1., 1., -3., 3.), .1))
@@ -250,7 +314,7 @@ def test_moving_tables_layout_and_attachment(monkeypatch):
     band, geom = MovingTables.layout([(a, 2), (b, 5)])
     wa, ha = 63 - 37 + 1, 55 - 25 + 1
     assert band == [37, 25, wa, ha, 0, 2, 83, 23, 16, 16, wa * ha * 8, 5]
-    assert geom == [50., 40., 10., 90.25, 30.5, 5.]
+    assert geom == [50., 40., 50., 40., 10., 0., 0., 90.25, 30.5, 90.25, 30.5, 5., 0., 0.]  # hold
     sim = routed_simulation(monkeypatch)
     sim.add_body("circle", (50., 40.), 10., translation=Translation((0., 0., 0., 0.), .1))
     sim._moving_tables = "tables"