Attempt to fix unsync bug

sardine_core/clock/internal_clock.py

@@ -114,6 +114,7 @@ def internal_origin(self, origin: float):
 
     @tempo.setter
     def tempo(self, new_tempo: NUMBER):
+        self.env.dispatch('tempo_change', self.tempo, new_tempo)
         new_tempo = float(new_tempo)
 
         if not 1 <= new_tempo <= 999:

sardine_core/clock/link_clock.py

@@ -125,6 +125,7 @@ def internal_origin(self, origin: float):
 
     @tempo.setter
     def tempo(self, new_tempo: float) -> None:
+        self.env.dispatch('tempo_change', self.tempo, new_tempo)
         if self._link is not None:
             session = self._link.captureSessionState()
             session.setTempo(new_tempo, self.beats_per_bar)

sardine_core/scheduler/async_runner.py

@@ -441,7 +441,11 @@ def _correct_interval(self, period: Union[float, int]):
         self._can_correct_interval = False
 
     def _correct_interval_background_job(self, period: Union[float, int]):
-        """Alternative version for fixed-rate background jobs"""
+        """
+        Alternative version for fixed-rate background jobs. The interval or
+        period is not indexed on the clock like with the _correct_interval 
+        method above.
+        """
         interval = period
         if self._can_correct_interval and interval != self._last_interval:
             time = self._expected_time
@@ -501,6 +505,7 @@ async def _runner(self):
 
         try:
             while self._is_ready_for_iteration():
+                #self._last_interval = self._get_period(self._last_state) * self.clock.beat_duration
                 try:
                     await self._run_once()
                 except Exception as exc:

sardine_core/scheduler/scheduler.py

@@ -16,6 +16,17 @@ def __init__(
         self._runners: dict[str, AsyncRunner] = {}
         self.deferred = deferred_scheduling
 
+    def _react_to_tempo_change(self, old_tempo: int|float, new_tempo: int|float):
+        """
+        In reaction to a tempo change, the scheduler should
+        trigger an event for each runner prompting to update
+        their current interval_shift. This prevents runners
+        from desynchronization everytime tempo change happens.
+        """
+        scale = old_tempo / new_tempo
+        for runner in self._runners.values():
+            runner.interval_shift *= scale
+
     def __repr__(self) -> str:
         n_runners = len(self._runners)
         return "<{} ({} {}) deferred={}>".format(
@@ -118,7 +129,10 @@ def _reload_runners(self, *, interval_correction: bool):
 
     def setup(self):
         self.register("stop")
+        self.register("tempo_change")
 
     def hook(self, event: str, *args):
         if event == "stop":
             self.reset()
+        if event == "tempo_change":
+            self._react_to_tempo_change(*args)