diff --git a/3rdparty/libremidi b/3rdparty/libremidi
index 75a3d27b22f..127fc87d04e 160000
--- a/3rdparty/libremidi
+++ b/3rdparty/libremidi
@@ -1 +1 @@
-Subproject commit 75a3d27b22f52cdff66edd759dea38ffe3b67d89
+Subproject commit 127fc87d04ecf5009a3169be7e83b54dd9a20add
diff --git a/CMakeLists.txt b/CMakeLists.txt
index cebb1f75bc8..f57f5703167 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -32,6 +32,58 @@ find_package(${QT_VERSION} COMPONENTS Core)
 ## at least with CMake 15.2
 set(OSSIA_SOURCE_FOLDER "${CMAKE_CURRENT_SOURCE_DIR}" CACHE INTERNAL "")
 set(OSSIA_3RDPARTY_FOLDER "${CMAKE_CURRENT_SOURCE_DIR}/3rdparty" CACHE INTERNAL "")
+
+if(WIN32)
+  # Pin the Windows target for every translation unit, whatever the compiler.
+  #
+  # <windows.h> defines _WIN32_WINNT itself, through <sdkddkver.h>, whenever it
+  # is not already set, so leaving it alone does not mean "no minimum" - it
+  # means each translation unit gets one depending on whether it reached
+  # <windows.h> at all. Headers that branch on it, Boost.Asio among them, then
+  # configure themselves differently from one file to the next: Asio reads it
+  # to decide BOOST_ASIO_HAS_STD_ATOMIC_WAIT, which changes the wait primitive
+  # it uses. That is an ODR violation, and nothing reports it because both
+  # spellings mangle the same.
+  #
+  # The defaults also disagree between toolchains: the Windows Kits header
+  # picks 0x0A00 while mingw-w64 picks _WIN32_WINNT_WS03, so a mingw build has
+  # been configuring itself for Server 2003 wherever this was left alone.
+  #
+  # Here rather than on the ossia target, and before any add_subdirectory: the
+  # dependencies we add as subdirectories compile Asio too - libremidi builds
+  # its own translation units on MSVC - and they are siblings of ossia rather
+  # than consumers of it, so a PUBLIC definition never reaches them. It is
+  # repeated in src/ossia_setup.cmake as PUBLIC so that projects consuming an
+  # installed ossia get it too.
+  #
+  # WINVER and NTDDI_VERSION are deliberately not set: sdkddkver.h derives
+  # WINVER from _WIN32_WINNT and NTDDI_VERSION from the SDK, in both
+  # toolchains, so setting them by hand only creates a way for them to
+  # disagree.
+  # And give Boost.Asio's global symbols a version-tagged name.
+  #
+  # Since 1.91 they are named through BOOST_ASIO_VERSIONED_NAME, which with no
+  # version namespace expands to the bare asio_ prefix - the names standalone
+  # Asio uses. Where Asio is compiled separately we emit strong definitions of
+  # them, so anything else in the link carrying its own standalone Asio
+  # collides: score's LSL addon compiles asio/impl/src.hpp, and the two meet as
+  # a duplicate asio_signal_handler.
+  #
+  # The tag encodes the Asio configuration, which is why this only holds
+  # together with the pin above; without it the namespace varies per TU and the
+  # duplicate symbol merely becomes an undefined one. It also requires that
+  # nothing forward-declares an Asio type in plain boost::asio, which would be
+  # ambiguous against the real one - see libremidi's backends/net/config.hpp,
+  # which declares io_context inside the same inline namespace we do.
+  #
+  # Standalone Asio has no equivalent knob, still hardcoding the bare names as
+  # of 1.36, so the versioning has to come from our side. A no-op before 1.91.
+  add_definitions(
+    -D_WIN32_WINNT=0x0A00
+    -DBOOST_ASIO_ENABLE_VERSION_NAMESPACE=1
+  )
+endif()
+
 include(OssiaOptions)
 
 # Dependencies
diff --git a/src/ossia/dataflow/execution_state.cpp b/src/ossia/dataflow/execution_state.cpp
index 0d825f000fd..a9b6eab35d9 100644
--- a/src/ossia/dataflow/execution_state.cpp
+++ b/src/ossia/dataflow/execution_state.cpp
@@ -525,23 +525,41 @@ auto exec_state_facade::timings(const token_request& t) const noexcept -> sample
 {
   sample_timings tm;
   static constexpr double speed_epsilon = 0.01;
-  if(t.speed > speed_epsilon)
+
+  if(t.start_sample >= 0 && t.length_sample >= 0)
   {
     [[likely]];
-    tm.start_sample = t.physical_start(impl->modelToSamplesRatio);
-
-    const auto tick_dur = t.physical_write_duration(impl->modelToSamplesRatio);
-    auto max_dur = int64_t(impl->bufferSize - tm.start_sample);
-    if(max_dur < 0)
-      max_dur = 0;
-
-    tm.length = std::min(tick_dur, max_dur);
+    // The producer of the token knew which samples of the buffer it stands
+    // for, and that knowledge cannot be reconstructed from the flick-quantised
+    // model dates - carrying it is the point. Clamp defensively: a span must
+    // never reach outside the buffer.
+    tm.start_sample = t.start_sample;
+    tm.length = t.length_sample;
+    if(tm.start_sample > impl->bufferSize)
+    {
+      [[unlikely]];
+      ossia::logger().error(
+          "token start_sample > bufferSize: {} > {}", tm.start_sample,
+          impl->bufferSize);
+      return {};
+    }
+    if(tm.start_sample + tm.length > impl->bufferSize)
+    {
+      [[unlikely]];
+      ossia::logger().error(
+          "token start_sample + length_sample > bufferSize: {} + {} > {}",
+          tm.start_sample, tm.length, impl->bufferSize);
+      tm.length = impl->bufferSize - tm.start_sample;
+    }
+    return tm;
   }
-  else if(t.speed < -speed_epsilon)
+
+  if(t.speed > speed_epsilon || t.speed < -speed_epsilon)
   {
-    tm.start_sample = -t.physical_start(impl->modelToSamplesRatio);
+    [[likely]];
+    tm.start_sample = t.physical_start(impl->modelToSamplesRatio);
 
-    const auto tick_dur = -t.physical_write_duration(impl->modelToSamplesRatio);
+    const auto tick_dur = t.physical_write_duration(impl->modelToSamplesRatio);
     auto max_dur = int64_t(impl->bufferSize - tm.start_sample);
     if(max_dur < 0)
       max_dur = 0;
diff --git a/src/ossia/dataflow/graph/tick_methods.hpp b/src/ossia/dataflow/graph/tick_methods.hpp
index 3890eaaf8cf..3565f34b8ac 100644
--- a/src/ossia/dataflow/graph/tick_methods.hpp
+++ b/src/ossia/dataflow/graph/tick_methods.hpp
@@ -97,9 +97,11 @@ struct tick_all_nodes
     const time_value new_date{e.samples_since_start};
 
     // TODO tempo / sig ?
+    token_request tok{old_date, new_date, 0_tv, 0_tv, 1.0, {}, ossia::root_tempo};
+    tok.start_sample = 0;
+    tok.length_sample = int32_t(samples);
     for(auto& node : g.get_nodes())
-      node->request(
-          token_request{old_date, new_date, 0_tv, 0_tv, 1.0, {}, ossia::root_tempo});
+      node->request(tok);
 
     g.state(e);
     std::atomic_thread_fence(std::memory_order_seq_cst);
@@ -143,6 +145,12 @@ struct buffer_tick
 
     tok.date = tok.prev_date + flicks;
 
+    // This is the one thing the audio callback knows for certain: the buffer
+    // is frameCount samples. Everything downstream carries cuts of this span
+    // rather than reconstructing them from the flick-quantised model dates.
+    tok.start_sample = 0;
+    tok.length_sample = int32_t(frameCount);
+
     // Notify the current transport state
     if(transport.allocated())
     {
@@ -208,7 +216,7 @@ struct precise_score_tick
       st.begin_tick();
       st.samples_since_start++;
       const ossia::token_request tok{};
-      itv.tick_offset(ossia::time_value{1}, 0_tv, tok);
+      itv.tick_offset(ossia::time_value{1}, 0_tv, tok, 0, 1);
       g.state(st);
       std::atomic_thread_fence(std::memory_order_seq_cst);
       st.commit();
diff --git a/src/ossia/dataflow/graph_node.cpp b/src/ossia/dataflow/graph_node.cpp
index 0b46543cb43..de51191fbaa 100644
--- a/src/ossia/dataflow/graph_node.cpp
+++ b/src/ossia/dataflow/graph_node.cpp
@@ -319,6 +319,12 @@ void graph_node::process_time(
 {
   auto [s, d] = exec_state_facade{&st}.timings(req);
   this->m_processed_frames += d;
+
+  // A span length is never negative, so the counter above cannot follow a
+  // rewind. The playhead can: map the date of the tick's first sample through
+  // the same model -> sample map the spans are taken from.
+  if(req.speed != 0.)
+    this->m_transport_frames = req.start_date_to_physical(st.modelToSamplesRatio);
 }
 
 void graph_node::all_notes_off() noexcept { }
diff --git a/src/ossia/dataflow/graph_node.hpp b/src/ossia/dataflow/graph_node.hpp
index 639d7ab65bd..efdbd7b5929 100644
--- a/src/ossia/dataflow/graph_node.hpp
+++ b/src/ossia/dataflow/graph_node.hpp
@@ -185,6 +185,21 @@ class OSSIA_EXPORT graph_node
     return m_processed_frames;
   }
 
+  /**
+   * Where the playhead sits on the timeline, in frames, at the first sample of
+   * the current tick.
+   *
+   * Distinct from processed_frames(): that counts audio pushed through the node
+   * and only ever rises, which is what a steady counter should do. This one
+   * follows the transport and goes back down when the timeline runs backwards.
+   * A plug-in wants the transport position, not the counter.
+   */
+  [[nodiscard]]
+  int64_t transport_frames() const noexcept
+  {
+    return m_transport_frames;
+  }
+
   virtual void all_notes_off() noexcept;
   token_request_vec requested_tokens;
 
@@ -192,6 +207,7 @@ class OSSIA_EXPORT graph_node
   inlets m_inlets;
   outlets m_outlets;
   int64_t m_processed_frames{};
+  int64_t m_transport_frames{};
 
   bool m_executed{};
   bool m_not_threadable{};
diff --git a/src/ossia/dataflow/nodes/faust/faust_utils.hpp b/src/ossia/dataflow/nodes/faust/faust_utils.hpp
index defa46ce9ee..12f0d51feb5 100644
--- a/src/ossia/dataflow/nodes/faust/faust_utils.hpp
+++ b/src/ossia/dataflow/nodes/faust/faust_utils.hpp
@@ -400,7 +400,7 @@ struct faust_node_utils
       Node& self, Dsp& dsp, const ossia::token_request& tk,
       const ossia::exec_state_facade& e)
   {
-    if(tk.forward())
+    if(!tk.paused())
     {
       const auto [st, d] = e.timings(tk);
       copy_controls(self);
@@ -504,7 +504,7 @@ struct faust_node_utils
       Node& self, Dsp& dsp, const ossia::token_request& tk,
       const ossia::exec_state_facade& e)
   {
-    if(tk.forward())
+    if(!tk.paused())
     {
       const auto [st, d] = e.timings(tk);
 
@@ -521,7 +521,7 @@ struct faust_node_utils
       Node& self, DspPoly& dsp, const ossia::token_request& tk,
       const ossia::exec_state_facade& e)
   {
-    if(tk.forward())
+    if(!tk.paused())
     {
       const auto [st, d] = e.timings(tk);
 
diff --git a/src/ossia/dataflow/nodes/sound.hpp b/src/ossia/dataflow/nodes/sound.hpp
index 16238baaf9d..e6b2aaa0851 100644
--- a/src/ossia/dataflow/nodes/sound.hpp
+++ b/src/ossia/dataflow/nodes/sound.hpp
@@ -11,6 +11,8 @@
 #include <ossia/detail/pod_vector.hpp>
 #include <ossia/detail/variant.hpp>
 
+#include <algorithm>
+
 namespace ossia
 {
 namespace snd
@@ -32,7 +34,10 @@ sample_info(int64_t bufferSize, double durationRatio, const ossia::token_request
     return _;
 
   _.samples_to_read = t.physical_read_duration(durationRatio);
-  _.samples_to_write = t.safe_physical_write_duration(durationRatio, bufferSize);
+
+  const auto room = t.safe_physical_write_duration(durationRatio, bufferSize);
+  const auto tick_dur = t.physical_write_duration(durationRatio);
+  _.samples_to_write = std::min(tick_dur, std::max<int64_t>(0, room));
 
   return _;
 }
@@ -260,19 +265,35 @@ struct sound_processing_info
 
   void set_native_tempo(double v) { tempo = v; }
 
-  // File sample at which a dropped sound must seek to align with an
-  // identical sound already playing at the same model time. Scales by
-  // |timeline_tempo| / file_tempo when stretching; falls back to to_sample().
+  // File sample an already-playing sound has reached at a given model date,
+  // i.e. where a sound dropped in mid-playback must seek to align with it.
+  //
+  // When stretching, both the model clock and the file consumption scale
+  // with the live tempo: the interval advances its date by
+  // tempo / root_tempo model samples per physical sample, and the stretcher
+  // consumes tempo / file_tempo file samples per physical sample. Their
+  // ratio is root_tempo / file_tempo whatever the transport tempo, tempo
+  // curve or speed are doing, so the file position is a pure function of
+  // the model date and the file's own tempo. Scaling by the *live* tempo
+  // here - as this used to do - lands wrong by a factor of
+  // live_tempo / root_tempo, i.e. it is only right at 120 BPM.
+  //
+  // In raw mode the file advances at one sample per physical sample while
+  // the model still runs at tempo / root_tempo, so there the live tempo is
+  // exactly what is needed to unscale the date; when it is not known
+  // (timeline_tempo == 0), the date is used as-is.
   [[nodiscard]] int64_t file_sample_for_model_time(
       time_value date, double timeline_tempo,
       int file_sample_rate) const noexcept
   {
     const int64_t base = to_sample(date, file_sample_rate);
-    const double abs_tempo = std::abs(timeline_tempo);
-    if(!m_resampler.stretch() || tempo <= 0.0 || abs_tempo <= 0.0)
-      return base;
+    if(m_resampler.stretch() && tempo > 0.0)
+      return int64_t(std::llround(double(base) * ossia::root_tempo / tempo));
 
-    return int64_t(double(base) * abs_tempo / tempo);
+    const double abs_tempo = std::abs(timeline_tempo);
+    if(abs_tempo > 0.0)
+      return int64_t(std::llround(double(base) * ossia::root_tempo / abs_tempo));
+    return base;
   }
 
   double update_stretch(
@@ -280,17 +301,10 @@ struct sound_processing_info
   {
     double stretch_ratio = 1.;
     double model_ratio = 1.;
-    if(tempo != 0.)
+    if(tempo != 0. && m_resampler.stretch())
     {
-      if(m_resampler.stretch())
-      {
-        model_ratio = ossia::root_tempo / this->tempo;
-        stretch_ratio = this->tempo / t.tempo;
-      }
-      else
-      {
-        model_ratio = ossia::root_tempo / t.tempo;
-      }
+      model_ratio = ossia::root_tempo / this->tempo;
+      stretch_ratio = this->tempo / t.tempo;
     }
 
     m_loop_duration_samples = m_loop_duration.impl * e.modelToSamples() * model_ratio;
diff --git a/src/ossia/dataflow/nodes/sound_libav.hpp b/src/ossia/dataflow/nodes/sound_libav.hpp
index d9c0fa843b0..b17ef85d394 100644
--- a/src/ossia/dataflow/nodes/sound_libav.hpp
+++ b/src/ossia/dataflow/nodes/sound_libav.hpp
@@ -62,21 +62,31 @@ class sound_libav final : public ossia::sound_node
 
   void transport(time_value flicks) override
   {
-    m_channel_q.clear();
-    ossia::seek_to_flick(
-        m_handle.format, m_handle.codec, m_handle.stream, flicks.impl, AVSEEK_FLAG_ANY);
+    transport_scaled(flicks, 0.);
   }
 
   void transport(time_value flicks, const ossia::tick_transport_info& tinfo) override
+  {
+    transport_scaled(flicks, tinfo.current_tempo);
+  }
+
+  // Same mapping as file_sample_for_model_time, in flicks: when stretching
+  // the file position is model_time * root_tempo / file_tempo whatever the
+  // transport is doing; in raw mode it is the model time unscaled by the
+  // live tempo when that is known.
+  void transport_scaled(time_value flicks, double timeline_tempo)
   {
     m_channel_q.clear();
-    // Scale flicks by |timeline_tempo| / file_tempo when stretching; otherwise
-    // seek at the raw model time. See file_sample_for_model_time.
     int64_t target_flicks = flicks.impl;
-    const double abs_tempo = std::abs(tinfo.current_tempo);
-    if(m_resampler.stretch() && tempo > 0.0 && abs_tempo > 0.0)
+    if(m_resampler.stretch() && tempo > 0.0)
+    {
+      target_flicks
+          = int64_t(std::llround(double(flicks.impl) * ossia::root_tempo / tempo));
+    }
+    else if(const double abs_tempo = std::abs(timeline_tempo); abs_tempo > 0.0)
     {
-      target_flicks = int64_t(double(flicks.impl) * abs_tempo / tempo);
+      target_flicks
+          = int64_t(std::llround(double(flicks.impl) * ossia::root_tempo / abs_tempo));
     }
     ossia::seek_to_flick(
         m_handle.format, m_handle.codec, m_handle.stream, target_flicks,
diff --git a/src/ossia/dataflow/nodes/sound_mmap.hpp b/src/ossia/dataflow/nodes/sound_mmap.hpp
index 8131847dd84..1cbeed451bc 100644
--- a/src/ossia/dataflow/nodes/sound_mmap.hpp
+++ b/src/ossia/dataflow/nodes/sound_mmap.hpp
@@ -73,8 +73,11 @@ class sound_mmap final : public ossia::sound_node
 
   void transport(time_value date) override
   {
+    // No transport info: the live tempo is unknown, but the stretching seek
+    // only needs the file's own tempo (see file_sample_for_model_time).
     if(m_handle)
-      m_resampler.transport(to_sample(date, m_handle.sampleRate()));
+      m_resampler.transport(
+          file_sample_for_model_time(date, 0., m_handle.sampleRate()));
   }
 
   void transport(time_value date, const ossia::tick_transport_info& tinfo) override
diff --git a/src/ossia/dataflow/nodes/sound_sampler.hpp b/src/ossia/dataflow/nodes/sound_sampler.hpp
index 52a72ae04bf..fe7d0aeffc6 100644
--- a/src/ossia/dataflow/nodes/sound_sampler.hpp
+++ b/src/ossia/dataflow/nodes/sound_sampler.hpp
@@ -21,7 +21,10 @@ struct sound_sampler
 
   void transport(time_value date)
   {
-    info->m_resampler.transport(to_sample(date, m_dataSampleRate));
+    // No transport info: the live tempo is unknown, but the stretching seek
+    // only needs the file's own tempo (see file_sample_for_model_time).
+    info->m_resampler.transport(
+        info->file_sample_for_model_time(date, 0., m_dataSampleRate));
   }
 
   void transport(time_value date, const ossia::tick_transport_info& tinfo)
@@ -87,8 +90,11 @@ struct sound_sampler
 
     const auto [samples_to_read, samples_to_write]
         = snd::sample_info(e.bufferSize(), e.modelToSamples(), t);
-    if(samples_to_read == 0)
-      return;
+    // Only the write count decides whether there is anything to do, as in
+    // sound_mmap and sound_libav. The read count is a floor over absolute model
+    // time while the write count is a floor over the offset into the buffer, so
+    // a tick can legitimately cover a sample without consuming a whole new one;
+    // bailing here left a hole and a stale m_prev_date.
     if(samples_to_write <= 0)
       return;
 
diff --git a/src/ossia/dataflow/nodes/timestretch/rubberband_stretcher.hpp b/src/ossia/dataflow/nodes/timestretch/rubberband_stretcher.hpp
index 3bf91768e5a..890ecc7bf76 100644
--- a/src/ossia/dataflow/nodes/timestretch/rubberband_stretcher.hpp
+++ b/src/ossia/dataflow/nodes/timestretch/rubberband_stretcher.hpp
@@ -54,7 +54,14 @@ static constexpr auto get_rubberband_preset(ossia::audio_stretch_mode mode)
 
 struct rubberband_stretcher
 {
-  // Priming variants exposed for SoundTest sweeps; production uses ZeroPadOnly.
+  // Priming variants exposed for the sound sync test sweeps; production uses
+  // BareRecipe, the recipe the RubberBand documentation prescribes for
+  // real-time mode: pad the input with getPreferredStartPad() zeros and trim
+  // getStartDelay() samples from the output. ZeroPadOnly, the previous
+  // default, skips the trim and therefore plays every stretched sound
+  // getStartDelay() samples (~23 ms at 44.1 kHz) late - late relative to raw
+  // and repitched sounds, and late by a ratio-dependent amount, so two
+  // stretched files at different source tempos flam against each other too.
   enum class prime_strategy : uint8_t
   {
     NoPrime,
@@ -63,7 +70,7 @@ struct rubberband_stretcher
     ExtendedDrain,
     PreRollRealAudio,
   };
-  static inline prime_strategy s_prime_strategy{prime_strategy::ZeroPadOnly};
+  static inline prime_strategy s_prime_strategy{prime_strategy::BareRecipe};
 
   rubberband_stretcher(
       uint32_t opt, std::size_t channels, std::size_t sampleRate, int64_t pos)
@@ -299,9 +306,30 @@ struct rubberband_stretcher
        || strategy == prime_strategy::PreRollRealAudio)
       return;
 
-    const int64_t drain_target
-        = (strategy == prime_strategy::ExtendedDrain) ? 2 * toPad
-                                                      : int64_t(m_rubberBand->getStartDelay());
+    int64_t drain_target;
+    if(strategy == prime_strategy::ExtendedDrain)
+    {
+      drain_target = 2 * toPad;
+    }
+    else
+    {
+      drain_target = int64_t(m_rubberBand->getStartDelay());
+
+      // The R2 engine reports aWindowSize/2 scaled only by the pitch, never
+      // by the time ratio, but the sample where input 0 actually surfaces in
+      // the output moves with the ratio. Measured with the click-track
+      // harness (SoundSyncTest) over ratios 0.52..1.17, the position is
+      // startDelay + ~0.375 * pad * (1 - ratio) within R2's own transient
+      // jitter, so trim that much more (or less). R3 accounts for the ratio
+      // itself.
+      if(!(options & RubberBand::RubberBandStretcher::OptionEngineFiner))
+      {
+        drain_target += int64_t(std::llround(
+            0.375 * double(toPad) * (1.0 - m_rubberBand->getTimeRatio())));
+      }
+      if(drain_target < 0)
+        drain_target = 0;
+    }
     if(drain_target <= 0)
       return;
 
diff --git a/src/ossia/dataflow/token_request.hpp b/src/ossia/dataflow/token_request.hpp
index 0852ac3c66b..2dd0c30722b 100644
--- a/src/ossia/dataflow/token_request.hpp
+++ b/src/ossia/dataflow/token_request.hpp
@@ -8,6 +8,7 @@
 #include <cassert>
 #include <cmath>
 #include <optional>
+#include <type_traits>
 
 #if defined(_LIBCPP_CONSTEXPR_SINCE_CXX23) || defined(_GLIBCXX23_CONSTEXPR)
 #define ossia_constexpr_msvc_workaround constexpr
@@ -18,13 +19,22 @@ namespace ossia
 {
 using quarter_note = double;
 
-//! One quantification point inside a tick: when it happens, and which
-//! subdivision it is.
+//! One quantification point inside a tick: when it happens, where it happens
+//! musically, and which subdivision it is.
 struct quantification_point
 {
   ossia::time_value date{};
   int64_t index{};
 
+  //! Where the point sits in musical time, in quarters.
+  //!
+  //! Kept alongside the date because the date is truncated to a whole flick: a
+  //! consumer that needs the sample the point lands on maps this through
+  //! token_request::physical_position rather than re-deriving it from the
+  //! date, which would round twice and land a sample early wherever the flick
+  //! truncation crosses a sample boundary.
+  double position{};
+
   friend bool
   operator==(const quantification_point&, const quantification_point&) noexcept
       = default;
@@ -80,6 +90,31 @@ struct token_request
     ossia::time_value orig_from = other.prev_date;
     ossia::time_value tick_amount = other.date - other.prev_date;
 
+    // The pieces of a looped tick must tile the parent's carried sample span
+    // the way the parent tiles the buffer. Cutting on the accumulated model
+    // amount with a single rounding keeps the cuts monotone, so consecutive
+    // pieces share their boundary sample by construction.
+    const int64_t total_amount
+        = tick_amount.impl >= 0 ? tick_amount.impl : -tick_amount.impl;
+    const bool has_span
+        = start_sample >= 0 && length_sample >= 0 && total_amount > 0;
+    int64_t consumed = 0;
+    const auto set_piece_span = [&](int64_t piece) constexpr {
+      if(has_span)
+      {
+        const int64_t s0 = start_sample
+                           + (int64_t{length_sample} * consumed + total_amount / 2)
+                                 / total_amount;
+        const int64_t s1
+            = start_sample
+              + (int64_t{length_sample} * (consumed + piece) + total_amount / 2)
+                    / total_amount;
+        other.start_sample = int32_t(s0);
+        other.length_sample = int32_t(s1 - s0);
+      }
+      consumed += piece;
+    };
+
     if(tick_amount >= 0_tv)
     {
       // Forward playback
@@ -90,6 +125,7 @@ struct token_request
         {
           other.prev_date = cur_from + start_offset;
           other.date = other.prev_date + tick_amount;
+          set_piece_span(tick_amount.impl);
           f(other);
           break;
         }
@@ -102,6 +138,7 @@ struct token_request
           other.prev_date = cur_from + start_offset;
           other.date = other.prev_date + this_tick;
 
+          set_piece_span(this_tick.impl);
           f(other);
 
           transport(start_offset);
@@ -111,40 +148,33 @@ struct token_request
     }
     else
     {
-      // Backward playback (tick_amount < 0)
-      while(tick_amount < 0_tv)
+      // Backward playback
+      const int64_t loop_dur = loop_duration.impl;
+      int64_t remaining = -tick_amount.impl;
+
+      while(remaining > 0)
       {
-        time_value cur_from{orig_from % loop_duration};
-        // Handle negative modulo: ensure cur_from is in [0, loop_duration)
-        if(cur_from.impl < 0)
-          cur_from.impl += loop_duration.impl;
+        int64_t cur_from = orig_from.impl % loop_dur;
+        if(cur_from < 0)
+          cur_from += loop_dur;
 
-        if(cur_from + tick_amount >= 0_tv)
+        if(cur_from == 0)
         {
-          // The backward tick fits within the current loop iteration
-          other.prev_date = cur_from + start_offset;
-          other.date = other.prev_date + tick_amount;
-          f(other);
-          break;
+          transport(start_offset + loop_duration);
+          cur_from = loop_dur;
         }
-        else
-        {
-          // Go back to the start of the loop, then wrap around
-          auto this_tick = -cur_from; // negative: go from cur_from back to 0
-          if(this_tick == 0_tv)
-            this_tick = -loop_duration; // already at 0, go back a full loop
 
-          tick_amount -= this_tick; // tick_amount becomes less negative
-          orig_from += this_tick;
-          other.prev_date = cur_from + start_offset;
-          other.date = other.prev_date + this_tick;
+        const int64_t this_tick = remaining < cur_from ? remaining : cur_from;
 
-          f(other);
+        other.prev_date = time_value{cur_from} + start_offset;
+        other.date = other.prev_date - time_value{this_tick};
 
-          // Wrap to end of loop
-          transport(start_offset + loop_duration);
-          other.offset -= this_tick; // this_tick is negative, so offset increases
-        }
+        set_piece_span(this_tick);
+        f(other);
+
+        remaining -= this_tick;
+        orig_from -= time_value{this_tick};
+        other.offset += time_value{this_tick};
       }
     }
   }
@@ -155,6 +185,11 @@ struct token_request
     return date - prev_date;
   }
 
+  [[nodiscard]] static constexpr double abs_speed(double s) noexcept
+  {
+    return s < 0. ? -s : s;
+  }
+
   //! The date of the first sample in the context of the parent.
   //! e.g. if we're at the start of our third buffer of 256 samples for
   //! a given time_interval, this will give 768.
@@ -163,15 +198,29 @@ struct token_request
   // C++23: [[ expects: speed != 0. ]]
   {
     assert(speed != 0.);
-    return this->prev_date.impl * ratio / speed;
+    return this->prev_date.impl * ratio / abs_speed(speed);
+  }
+
+  //! The sample a position in this tick's model time maps to, measured from
+  //! the start of the buffer. Non-decreasing, so spans taken as differences of
+  //! it can neither overlap nor leave a hole: the end of one is the start of
+  //! the next by construction, not by agreement.
+  [[nodiscard]] constexpr physical_time
+  sample_at(ossia::time_value tick_position, double ratio) const noexcept
+  {
+    assert(speed != 0.);
+    return constexpr_floor(tick_position.impl * ratio / abs_speed(speed));
   }
 
-  //! Where we must start to read / write in our physical buffers
+  //! Where we must start to read / write in our physical buffers.
+  //! The producer's word is taken when it gave one: reconstructing the sample
+  //! from the flick-quantised offset can land one sample off the actual cut.
   [[nodiscard]] constexpr physical_time physical_start(double ratio) const noexcept
   // C++23: [[ expects: speed != 0. ]]
   {
-    assert(speed != 0.);
-    return this->offset.impl * ratio / speed;
+    if(start_sample >= 0)
+      return start_sample;
+    return sample_at(this->offset, ratio);
   }
 
   //! Given a sound file at 44100 and a system rate at 44100,
@@ -180,17 +229,25 @@ struct token_request
   [[nodiscard]] constexpr physical_time
   physical_read_duration(double ratio) const noexcept
   {
-    return constexpr_ceil(abs(date - prev_date).impl * ratio);
+    // A difference of one map over absolute model time, so consecutive ticks
+    // read consecutive samples with neither a gap nor an overlap.
+    const auto a = prev_date.impl < date.impl ? prev_date.impl : date.impl;
+    const auto b = prev_date.impl < date.impl ? date.impl : prev_date.impl;
+    return constexpr_floor(b * ratio) - constexpr_floor(a * ratio);
   }
 
   //! Given a sound file at 44100 and a system rate at 44100,
-  //! this is the amount of samples that we must write in the audio buffer
+  //! this is the amount of samples that we must write in the audio buffer.
+  //! As with physical_start, the span the producer carried wins over the
+  //! flick-rounded reconstruction.
   [[nodiscard]] constexpr physical_time
   physical_write_duration(double ratio) const noexcept
   // C++23: [[ expects: speed != 0. ]]
   {
-    assert(speed != 0.);
-    return constexpr_ceil(abs(date - prev_date).impl * ratio / speed);
+    if(length_sample >= 0)
+      return length_sample;
+    return sample_at(this->offset + abs(date - prev_date), ratio)
+           - sample_at(this->offset, ratio);
   }
 
   //! This is an upper bound on what we can write to a buffer.
@@ -198,8 +255,43 @@ struct token_request
   safe_physical_write_duration(double ratio, int bufferSize) const noexcept
   // C++23: [[ expects: speed != 0. ]]
   {
-    assert(speed != 0.);
-    return constexpr_floor(bufferSize - offset.impl * ratio / speed);
+    return bufferSize - physical_start(ratio);
+  }
+
+  //! Where a musical position this tick crosses falls in the samples it
+  //! covers, as an offset from the start of the tick's span.
+  //!
+  //! The single map from musical time to a sample, for every consumer of the
+  //! grid: the metronome and the quantification points both go through it, so
+  //! a click and a quantized event on the same bar line cannot land on
+  //! different frames. It also matches halp::tick_musical, so a native node
+  //! and an avendish plug-in on one score snap to the same sample.
+  //!
+  //! Do not reconstruct this from a point's date: the date is truncated to a
+  //! whole flick, and flooring that into a sample rounds a second time.
+  [[nodiscard]] constexpr physical_time
+  physical_position(double musical_position, double ratio) const noexcept
+  {
+    // A tick with no speed advances through no samples, so everything in it
+    // belongs to the first one. Reconstructing the span below would divide by
+    // that speed - a span the producer carried needs no such thing.
+    if(speed == 0. && length_sample < 0)
+      return 0;
+
+    const int64_t len = physical_write_duration(ratio);
+    if(len <= 0)
+      return 0;
+
+    const double musical_tick_duration = musical_end_position - musical_start_position;
+    if(musical_tick_duration == 0.)
+      return 0;
+
+    // Positive in both directions: rewinding, the distance to the position and
+    // the duration of the tick are both negative.
+    const double r
+        = (musical_position - musical_start_position) / musical_tick_duration;
+    const int64_t s = constexpr_floor(r * len);
+    return s < 0 ? int64_t(0) : (s >= len ? len - 1 : s);
   }
 
   //! Is the given value in the tick defined by this token_request
@@ -213,7 +305,29 @@ struct token_request
   [[nodiscard]] constexpr physical_time
   to_physical_time_in_tick(ossia::time_value global_time, double ratio) const noexcept
   {
-    return (global_time - prev_date + offset).impl * ratio / speed;
+    // How far into the tick this date sits, counted forwards in both directions.
+    const int64_t in_tick
+        = speed < 0. ? (prev_date - global_time).impl : (global_time - prev_date).impl;
+
+    // Place it inside the span this tick was actually handed, so an event and
+    // the audio it belongs to cannot end up on different samples. Reconstructing
+    // the position from the model dates can miss the span by one.
+    if(start_sample >= 0 && length_sample >= 0)
+    {
+      const int64_t dt = abs(date - prev_date).impl;
+      if(dt <= 0)
+        return start_sample;
+      int64_t s = start_sample
+                  + constexpr_floor(double(in_tick) / double(dt) * length_sample);
+      if(s < start_sample)
+        s = start_sample;
+      else if(s > int64_t(start_sample) + length_sample)
+        s = int64_t(start_sample) + length_sample;
+      return s;
+    }
+
+    assert(speed != 0.);
+    return sample_at(this->offset + ossia::time_value{in_tick}, ratio);
   }
 
   //! Maps a time value in the frame of reference of this tick's node to a time
@@ -229,8 +343,9 @@ struct token_request
   [[nodiscard]] constexpr time_value
   from_physical_time_in_tick(ossia::physical_time phys_time, double ratio) const noexcept
   {
-    return time_value{
-        constexpr_floor(phys_time * (speed / ratio) + prev_date.impl - offset.impl)};
+    assert(speed != 0.);
+    const double in_tick = phys_time - physical_start(ratio);
+    return time_value{constexpr_floor(in_tick * (speed / ratio) + prev_date.impl)};
   }
 
   //! If we are in a kind of hierarchical object, return where we are at the
@@ -249,130 +364,82 @@ struct token_request
   //! Does the tick go backward (e.g. speed < 0)
   [[nodiscard]] constexpr bool backward() const noexcept { return date < prev_date; }
 
-  [[nodiscard]] ossia_constexpr_msvc_workaround std::optional<time_value>
-  get_quantification_date_for_bars_or_longer(double rate) const noexcept
-  {
-    std::optional<time_value> quantification_date;
-    const double bars_per_quantization = 1.0 / rate;
-
-    // Convert positions to bar numbers from the last signature
-    const double start_bar_position
-        = (musical_start_position - musical_start_last_signature)
-          / (4.0 * signature.upper / signature.lower);
-    const double end_bar_position = (musical_end_position - musical_start_last_signature)
-                                    / (4.0 * signature.upper / signature.lower);
 
-    // Check if we're exactly on a quantization point at the start
-    const double start_remainder = std::fmod(start_bar_position, bars_per_quantization);
-    if(std::abs(start_remainder) < 0.0001 && musical_start_position >= 0)
-    {
-      quantification_date = prev_date;
-    }
-    else
-    {
-      // Find the next quantization bar after start
-      const double start_quant_bar
-          = std::floor(start_bar_position / bars_per_quantization);
-      const double next_quant_bar_number = (start_quant_bar + 1) * bars_per_quantization;
-
-      // Check if this quantization point falls within our tick (but NOT at the end)
-      if(next_quant_bar_number > start_bar_position
-         && next_quant_bar_number < end_bar_position)
-      {
-        // Calculate the musical position of this quantization point
-        const double quant_musical_position
-            = musical_start_last_signature
-              + next_quant_bar_number * (4.0 * signature.upper / signature.lower);
-
-        // Map this to a time value
-        const double musical_tick_duration
-            = musical_end_position - musical_start_position;
-        const double ratio
-            = (quant_musical_position - musical_start_position) / musical_tick_duration;
-        const time_value dt = date - prev_date;
-
-        time_value potential_date = prev_date + dt * ratio;
-
-        // Extra safety check: ensure we're not at the boundary
-        if(potential_date < date)
-        {
-          quantification_date = potential_date;
-        }
-        else
-        {
-          return std::nullopt;
-        }
-      }
-    }
-    return quantification_date;
-  }
-
-  [[nodiscard]] ossia_constexpr_msvc_workaround std::optional<time_value>
-  get_quantification_date_for_shorter_than_bars(double rate) const noexcept
+  //! Calls fn(bar_line, next_bar_line) for every bar segment the tick touches,
+  //! in increasing musical order.
+  //!
+  //! Bar lines come from two places and both matter: the ones the signature
+  //! implies, and the one the interval reported for the far end of the tick.
+  //! A signature change puts a bar line where the arithmetic alone would not,
+  //! so the grid restarts there.
+  template <typename F>
+  void for_each_bar_segment(double lo, double hi, F&& fn) const noexcept
   {
-    // Quantize relative to quarter divisions
-    // TODO ! if there is a bar change,
-    // and no prior quantization date before that, we have to quantize to the
-    // bar change
-    const double start_quarter = (musical_start_position - musical_start_last_bar);
-    const double end_quarter = (musical_end_position - musical_start_last_bar);
+    const bool valid_sig = signature.upper > 0 && signature.lower > 0;
+    const double quarters_in_bar
+        = valid_sig ? 4. * signature.upper / signature.lower : 4.;
+    if(!(quarters_in_bar > 0.))
+      return;
 
-    // duration of what we quantify in terms of quarters
-    const double musical_quant_dur = rate / 4.;
-    const double start_quant = std::floor(start_quarter * musical_quant_dur);
-    const double end_quant = std::floor(end_quarter * musical_quant_dur);
+    constexpr double eps = 1e-9;
+    const bool rewinding = date < prev_date;
+    const double near_bar = rewinding ? musical_end_last_bar : musical_start_last_bar;
+    const double far_bar = rewinding ? musical_start_last_bar : musical_end_last_bar;
 
-    if(start_quant != end_quant)
+    // Up to the reported far bar, on the grid the near bar defines.
+    double b = near_bar;
+    for(int i = 0; i < 1024 && b < far_bar - eps; i++)
     {
-      if(end_quant == end_quarter * musical_quant_dur)
-      {
-        // We want quantization on start, not on end
-        return std::nullopt;
-      }
-      // Date to quantify is the next one :
-      const double musical_tick_duration = musical_end_position - musical_start_position;
-      const double quantified_duration
-          = (musical_start_last_bar + (start_quant + 1) * 4. / rate)
-            - musical_start_position;
-      const double ratio = (date - prev_date).impl / musical_tick_duration;
-
-      return prev_date + quantified_duration * ratio;
+      const double next = (b + quarters_in_bar < far_bar) ? b + quarters_in_bar : far_bar;
+      if(next > lo + eps && b < hi + eps)
+        fn(b, next);
+      b += quarters_in_bar;
     }
-    else if(start_quant == start_quarter * musical_quant_dur)
+
+    // From the far bar on, on the grid it defines.
+    b = (far_bar > near_bar) ? far_bar : near_bar;
+    for(int i = 0; i < 1024 && b < hi + eps; i++)
     {
-      // We start on a signature change
-      return prev_date;
-    }
-    else
-    {
-      return std::nullopt;
+      fn(b, b + quarters_in_bar);
+      b += quarters_in_bar;
     }
   }
 
   //! Given a quantification rate (1 for bars, 2 for half, 4 for quarters...)
-  //! return the next occurring quantification date, if such date is in the tick
+  //! return the next occurring quantification point, if it is in the tick
   //! defined by this token_request.
-  [[nodiscard]] ossia_constexpr_msvc_workaround std::optional<time_value>
-  get_quantification_date(double rate) const noexcept
+  //!
+  //! This is the first of get_quantification_dates(), not a second
+  //! implementation of it: a node that takes one point and a node that takes
+  //! them all have to agree about where the grid is.
+  [[nodiscard]] std::optional<quantification_point>
+  get_quantification_point(double rate) const noexcept
   {
     if(prev_date == date)
       return std::nullopt;
 
-    if(rate <= 0.)
-      return prev_date;
+    // Quantized triggers are not interactive while rewinding.
+    if(backward())
+      return std::nullopt;
 
-    const double musical_tick_duration = musical_end_position - musical_start_position;
-    if(musical_tick_duration <= 0.)
-      return prev_date;
+    const auto pts = get_quantification_dates(rate);
+    if(pts.empty())
+      return std::nullopt;
+    return pts[0];
+  }
 
-    if(rate <= 1.)
-    {
-      return get_quantification_date_for_bars_or_longer(rate);
-    }
-    else
-    {
-      return get_quantification_date_for_shorter_than_bars(rate);
-    }
+  //! The date of the next occurring quantification point.
+  //!
+  //! For consumers that schedule in model time. A consumer that needs the
+  //! sample the point lands on takes get_quantification_point() and maps its
+  //! position through physical_position(): the date here is truncated to a
+  //! whole flick, and flooring it into a sample rounds a second time.
+  [[nodiscard]] std::optional<time_value>
+  get_quantification_date(double rate) const noexcept
+  {
+    if(const auto pt = get_quantification_point(rate))
+      return pt->date;
+    return std::nullopt;
   }
 
   //! Every quantification date occurring in this tick, in order.
@@ -391,69 +458,167 @@ struct token_request
       return res;
 
     const double musical_tick_duration = musical_end_position - musical_start_position;
-    if(rate <= 0. || musical_tick_duration <= 0.)
-    {
-      res.push_back({prev_date, 0});
-      return res;
-    }
+    const bool rewinding = date < prev_date;
 
-    // Distance in quarter notes between two consecutive points, and the musical
-    // position their count is relative to.
-    double unit{};
-    double origin{};
-    if(rate <= 1.)
+    // A musical duration that disagrees with the direction of the tick did not
+    // come from it - subdividing it would place every point at prev_date.
+    if(rate <= 0. || musical_tick_duration == 0.
+       || (musical_tick_duration < 0.) != rewinding)
     {
-      // A bar or longer: the rate is a fraction of a bar.
-      const bool valid_sig = signature.upper > 0 && signature.lower > 0;
-      const double bar = valid_sig ? 4. * signature.upper / signature.lower : 4.;
-      unit = bar / rate;
-      origin = musical_start_last_signature;
-    }
-    else
-    {
-      // Shorter: a subdivision of the quarter note.
-      unit = 4. / rate;
-      origin = musical_start_last_bar;
-    }
-
-    if(!(unit > 0.))
+      res.push_back({prev_date, 0, musical_start_position});
       return res;
+    }
 
     // A point falling exactly on the end of the tick belongs to the next one,
     // so the interval is [start; end[ - which is also what makes the first
     // element agree with get_quantification_date().
     constexpr double eps = 1e-9;
-    const double start = (musical_start_position - origin) / unit;
-    const double end = (musical_end_position - origin) / unit;
-
     const time_value tick_duration = date - prev_date;
-    for(int64_t k = int64_t(std::ceil(start - eps)); k < end - eps; k++)
+    const bool valid_sig = signature.upper > 0 && signature.lower > 0;
+    const double quarters_in_bar = valid_sig ? 4. * signature.upper / signature.lower : 4.;
+
+    // A point is kept if it lands inside the tick; false means we walked past
+    // the end and can stop.
+    const auto try_push = [&](double musical_position, int64_t index) {
+      // Scale the musical distance to this point by the tick, rather than
+      // scaling the tick by a normalised position. The two associate
+      // differently in floating point and the result is truncated to a whole
+      // flick, so the other order lands a flick short on dates that come out
+      // exact in this one.
+      const double scale = double(tick_duration.impl) / musical_tick_duration;
+      time_value d
+          = prev_date + (musical_position - musical_start_position) * scale;
+
+      // The tick owns [start; end[ in musical positions as well as in dates:
+      // a point sitting musically on the far end belongs to the next tick,
+      // even when truncating its date to a whole flick pulls it inside this
+      // one. Without this, the point fires here at the last flick AND in the
+      // next tick at its first one.
+      if(rewinding)
+      {
+        if(musical_position <= musical_end_position)
+          return false;
+        if(d > prev_date)
+          d = prev_date;
+        if(d <= date)
+          return false;
+      }
+      else
+      {
+        if(musical_position >= musical_end_position)
+          return false;
+        if(d < prev_date)
+          d = prev_date;
+        if(d >= date)
+          return false;
+      }
+
+      res.push_back({d, index, musical_position});
+      // A tick spanning this many points means the rate is nonsense: stop
+      // rather than fill memory.
+      return res.size() < 1024;
+    };
+
+    if(rate <= 1.)
     {
-      const double ratio
-          = (k * unit + origin - musical_start_position) / musical_tick_duration;
-      time_value d = prev_date + tick_duration * ratio;
+      // A bar or longer: the rate is a fraction of a bar, counted from the last
+      // signature change, and no bar line subdivides it.
+      const double unit = quarters_in_bar / rate;
+      if(!(unit > 0.))
+        return res;
+
+      const double origin = musical_start_last_signature;
+      const double start = (musical_start_position - origin) / unit;
+      const double end = (musical_end_position - origin) / unit;
+      const int64_t first = rewinding ? int64_t(std::floor(start + eps))
+                                      : int64_t(std::ceil(start - eps));
+
+      for(int64_t k = first; rewinding ? (k > end + eps) : (k < end - eps);
+          k += rewinding ? -1 : 1)
+      {
+        if(!try_push(k * unit + origin, k))
+          break;
+      }
+      return res;
+    }
 
-      if(d < prev_date)
-        d = prev_date;
-      if(d >= date)
-        break;
+    // Shorter than a bar: a subdivision of the quarter note, counted from the
+    // bar it falls in. The grid restarts at every bar line, so a bar whose
+    // length is not a whole number of divisions (7/8 against a half-note grid)
+    // does not carry a stale phase into the next one, and the bar line itself
+    // is always a point.
+    const double unit = 4. / rate;
+    if(!(unit > 0.) || !(quarters_in_bar > 0.))
+      return res;
 
-      res.push_back({d, k});
+    const double lo = rewinding ? musical_end_position : musical_start_position;
+    const double hi = rewinding ? musical_start_position : musical_end_position;
 
-      // A tick spanning this many points means the rate is nonsense: stop
-      // rather than fill memory.
-      if(res.size() >= 1024)
-        break;
+    // Collect the segments first so a rewinding walk can take them in reverse:
+    // the points inside a segment are monotone in k, and so are the segments.
+    ossia::small_vector<std::pair<double, double>, 8> segments;
+    for_each_bar_segment(lo, hi, [&](double bar_line, double next_bar) {
+      if(segments.size() < 1024)
+        segments.push_back({bar_line, next_bar});
+    });
+
+    const auto walk_segment = [&](double bar_line, double next_bar) {
+      const int divs = int(std::ceil((next_bar - bar_line) / unit)) + 1;
+      if(!rewinding)
+      {
+        for(int64_t k = 0; k <= divs; k++)
+        {
+          const double p = bar_line + k * unit;
+          if(p >= next_bar - eps || p > hi + eps)
+            return true;
+          if(p < lo)
+            continue;
+          if(!try_push(p, k))
+            return false;
+        }
+      }
+      else
+      {
+        for(int64_t k = divs; k >= 0; k--)
+        {
+          const double p = bar_line + k * unit;
+          if(p >= next_bar - eps || p > hi + eps)
+            continue;
+          if(p < lo)
+            return true;
+          if(!try_push(p, k))
+            return false;
+        }
+      }
+      return true;
+    };
+
+    if(!rewinding)
+    {
+      for(const auto& [b, n] : segments)
+        if(!walk_segment(b, n))
+          break;
+    }
+    else
+    {
+      for(auto it = segments.rbegin(); it != segments.rend(); ++it)
+        if(!walk_segment(it->first, it->second))
+          break;
     }
     return res;
   }
 
-  //! Like physical_quantification_date, but returns a date mapped to this tick
+  //! The next quantification point, as a sample offset into the buffer.
+  //!
+  //! Mapped through physical_position, the same map the metronome and every
+  //! grid consumer use, so a click and a quantized event on one bar line land
+  //! on one sample.
   [[nodiscard]] ossia_constexpr_msvc_workaround std::optional<physical_time>
   get_physical_quantification_date(double rate, double modelToSamples) const noexcept
   {
-    if(auto d = get_quantification_date(rate))
-      return to_physical_time_in_tick(*d, modelToSamples);
+    if(auto pt = get_quantification_point(rate))
+      return physical_start(modelToSamples)
+             + physical_position(pt->position, modelToSamples);
     return {};
   }
 
@@ -461,51 +626,89 @@ struct token_request
   constexpr void
   metronome(double modelToSamplesRatio, Tick tick, Tock tock) const noexcept
   {
-    if((musical_end_last_bar != musical_start_last_bar) || musical_start_position == 0.)
-    {
-      // There is a bar change in this tick, start the up tick
-      const double musical_tick_duration = musical_end_position - musical_start_position;
-      if(musical_tick_duration != 0)
+    const double musical_tick_duration = musical_end_position - musical_start_position;
+    const bool rewinding = backward();
+
+    // A musical duration that disagrees with the direction of the tick did not
+    // come from it, and interpolating in it would land outside the buffer.
+    if(musical_tick_duration == 0. || (musical_tick_duration < 0.) != rewinding)
+      return;
+
+    // A tick shorter than a sample covers no whole sample, but the grid point
+    // in it still belongs to one: the sample its span starts on, which is
+    // offset 0. Placement depends on the length, emission must not.
+    const int64_t samples_tick_duration = physical_write_duration(modelToSamplesRatio);
+    if(samples_tick_duration < 0)
+      return;
+
+    // The same map the quantification points use, so a click and a quantized
+    // event on one bar line land on one sample.
+    const auto sample_of = [&](double musical_position) {
+      return physical_position(musical_position, modelToSamplesRatio);
+    };
+
+    const double quarters_in_bar = 4. * signature.upper / signature.lower;
+    if(!(quarters_in_bar > 0.))
+      return;
+
+    // Walk every grid point the tick covers rather than only the last one: in
+    // 7/8 the third beat and the following bar line are half a quarter apart,
+    // so a tick of a moderate length steps over both.
+    const double lo = rewinding ? musical_end_position : musical_start_position;
+    const double hi = rewinding ? musical_start_position : musical_end_position;
+    const double bar0 = rewinding ? musical_end_last_bar : musical_start_last_bar;
+
+    // A grid point sitting exactly on a tick boundary belongs to the tick that
+    // starts on it, where it is sample 0, not to the one that ends on it, where
+    // it would be the last sample and so a sample early. Half-open at the end
+    // the tick is heading towards, in both directions.
+    const auto emit = [&](double p, bool is_bar) {
+      if(rewinding ? (p > hi || p <= lo) : (p < lo || p >= hi))
+        return;
+      if(is_bar)
+        tick(sample_of(p));
+      else
+        tock(sample_of(p));
+    };
+
+    // The same bar segments the quantification grid uses, so a click and a
+    // quantized event at the same bar line land on the same sample.
+    double seg_lo[64]{};
+    double seg_hi[64]{};
+    int n_seg = 0;
+    for_each_bar_segment(lo, hi, [&](double bar_line, double next_bar) {
+      if(n_seg < 64)
       {
-        const double musical_bar_start = musical_end_last_bar - musical_start_position;
-        const int64_t samples_tick_duration
-            = physical_write_duration(modelToSamplesRatio);
-        if(samples_tick_duration > 0)
-        {
-          const double ratio = musical_bar_start / musical_tick_duration;
-          const int64_t hi_start_sample = samples_tick_duration * ratio;
-          tick(hi_start_sample);
-        }
+        seg_lo[n_seg] = bar_line;
+        seg_hi[n_seg] = next_bar;
+        n_seg++;
       }
-    }
-    else
-    {
-      const int64_t start_quarter
-          = std::floor(musical_start_position - musical_start_last_bar);
-      const int64_t end_quarter
-          = std::floor(musical_end_position - musical_start_last_bar);
-      if(start_quarter != end_quarter)
+    });
+
+    const auto walk_segment = [&](double bar_line, double next_bar) {
+      if(!rewinding)
       {
-        // There is a quarter change in this tick, start the down tick
-        // start_position is prev_date
-        // end_position is date
-        const double musical_tick_duration
-            = musical_end_position - musical_start_position;
-        if(musical_tick_duration != 0)
-        {
-          const double musical_bar_start
-              = (end_quarter + musical_start_last_bar) - musical_start_position;
-          const int64_t samples_tick_duration
-              = physical_write_duration(modelToSamplesRatio);
-          if(samples_tick_duration > 0)
-          {
-            const double ratio = musical_bar_start / musical_tick_duration;
-            const int64_t lo_start_sample = samples_tick_duration * ratio;
-            tock(lo_start_sample);
-          }
-        }
+        emit(bar_line, true);
+        for(double q = bar_line + 1.; q < next_bar - 1e-9; q += 1.)
+          emit(q, false);
       }
-    }
+      else
+      {
+        double last = bar_line;
+        for(double q = bar_line + 1.; q < next_bar - 1e-9; q += 1.)
+          last = q;
+        for(double q = last; q > bar_line + 1e-9; q -= 1.)
+          emit(q, false);
+        emit(bar_line, true);
+      }
+    };
+
+    if(!rewinding)
+      for(int i = 0; i < n_seg; i++)
+        walk_segment(seg_lo[i], seg_hi[i]);
+    else
+      for(int i = n_seg - 1; i >= 0; i--)
+        walk_segment(seg_lo[i], seg_hi[i]);
   }
 
   [[nodiscard]] constexpr bool unexpected_bar_change() const noexcept
@@ -519,6 +722,9 @@ struct token_request
       // e.g. start = 4 -> end = 8  ; signature = 6/8 : bad
       // e.g. start = 4 -> end = 7  ; signature = 6/8 : good
 
+      if(bar_difference < 0.)
+        bar_difference = -bar_difference;
+
       double quarters_sig = 4. * double(signature.upper) / signature.lower;
       double div = bar_difference / quarters_sig;
       bool unexpected = div - int64_t(div) > 0.000001;
@@ -527,9 +733,28 @@ struct token_request
     return false;
   }
 
+  //! The fraction of the tick [prev_date; t] represents, in [0; 1], correct
+  //! in both playback directions. Used to split the carried sample span the
+  //! same way the model dates are split.
+  [[nodiscard]] constexpr double tick_fraction_at(time_value t) const noexcept
+  {
+    const double total = double(date.impl - prev_date.impl);
+    if(total == 0.)
+      return 0.;
+    double f = double(t.impl - prev_date.impl) / total;
+    if(f < 0.)
+      f = 0.;
+    else if(f > 1.)
+      f = 1.;
+    return f;
+  }
+
   constexpr void set_end_time(time_value t) noexcept
   // C++23: [[ expects: t <= this->date && t > this->prev_date ]]
   {
+    if(length_sample > 0)
+      length_sample = int32_t(length_sample * tick_fraction_at(t) + 0.5);
+
     const auto old_date = date;
     date = t;
 
@@ -545,6 +770,13 @@ struct token_request
   constexpr void set_start_time(time_value t) noexcept
   // C++23: [[ expects: t <= this->date && t > this->prev_date ]]
   {
+    if(length_sample > 0)
+    {
+      const auto skipped = int32_t(length_sample * tick_fraction_at(t) + 0.5);
+      start_sample += skipped;
+      length_sample -= skipped;
+    }
+
     const auto old_date = prev_date;
     prev_date = t;
 
@@ -581,6 +813,23 @@ struct token_request
   double tempo{ossia::root_tempo};
   time_signature signature{}; // Time signature at start
 
+  //! The span of the audio buffer this token covers, in samples: this token's
+  //! node must write samples [start_sample; start_sample + length_sample[.
+  //!
+  //! Decided by whoever cut the tick (the root audio callback, or a scenario
+  //! splitting it on an interval boundary) and carried verbatim, because it
+  //! cannot be reconstructed: the model dates are quantised to whole flicks,
+  //! so dividing them back by the speed lands next to the sample the cut was
+  //! actually taken at, and the last sample of the buffer ends up written by
+  //! nobody. -1 means the producer did not know the buffer (hand-made tokens,
+  //! non-audio drivers); consumers then fall back to deriving the span from
+  //! the model dates.
+  int32_t start_sample{-1};
+  int32_t length_sample{-1};
+
+  bool start_discontinuous{};
+  bool end_discontinuous{};
+
   ossia::quarter_note musical_start_last_signature{}; // Position of the last bar
                                                       // signature change in quarter
                                                       // notes (at prev_date)
@@ -590,10 +839,14 @@ struct token_request
   ossia::quarter_note musical_end_last_bar{};   // Position of the last bar start in
                                                 // quarter notes (at date)
   ossia::quarter_note musical_end_position{};   // Current position in quarter notes
-  bool start_discontinuous{};
-  bool end_discontinuous{};
 };
 
+// Copied per node per tick on the audio thread: it has to stay a POD that
+// memcpys, and it should not grow carelessly.
+static_assert(std::is_trivially_copyable_v<token_request>);
+static_assert(std::is_standard_layout_v<token_request>);
+static_assert(sizeof(token_request) == 104);
+
 inline bool operator==(const token_request& lhs, const token_request& rhs)
 {
   return lhs.prev_date == rhs.prev_date && lhs.date == rhs.date
diff --git a/src/ossia/editor/scenario/detail/scenario_execution.cpp b/src/ossia/editor/scenario/detail/scenario_execution.cpp
index 1a4709bf3de..77698c04dff 100644
--- a/src/ossia/editor/scenario/detail/scenario_execution.cpp
+++ b/src/ossia/editor/scenario/detail/scenario_execution.cpp
@@ -129,7 +129,8 @@ static const constexpr progress_mode mode{PROGRESS_MAX};
 
 void scenario::run_interval(
     ossia::time_interval& interval, const ossia::token_request& tk,
-    const time_value& tick_ms, ossia::time_value tick, ossia::time_value offset)
+    const time_value& tick_ms, ossia::time_value tick, ossia::time_value offset,
+    int32_t start_sample, int32_t end_sample)
 {
   const auto& cst_old_date = interval.get_date();
   auto cst_max_dur = interval.get_max_duration();
@@ -143,31 +144,60 @@ void scenario::run_interval(
 
   interval.set_parent_speed(tk.speed);
 
+  // [start_sample; end_sample[ is the window of the audio buffer this
+  // dispatch stands for. When the interval ends inside it, the cut is decided
+  // here, in samples: the interval takes the samples up to the cut and the
+  // overtick hands the rest to whatever the sync starts. Deciding the cut in
+  // model time and dividing back by the speed - what used to happen - loses
+  // the sub-flick remainders and leaves buffer tails written by nobody.
+  const bool has_span = start_sample >= 0 && end_sample >= start_sample;
+  const int32_t window = has_span ? end_sample - start_sample : -1;
+  const auto cut_at = [&](double parent_time) -> int32_t {
+    if(!has_span)
+      return -1;
+    if(tick.impl <= 0 || parent_time <= 0.)
+      return start_sample;
+    if(parent_time >= double(tick.impl))
+      return end_sample;
+    const auto c
+        = start_sample
+          + int32_t(std::llround(window * (parent_time / double(tick.impl))));
+    return c < start_sample ? start_sample : (c > end_sample ? end_sample : c);
+  };
+
   // Tick without going over the max
   // so that the state is not 1.01*automation for instance.
   if(!cst_max_dur.infinite())
   {
-    if(auto s = interval.get_speed(interval.get_date()); BOOST_LIKELY(s >= 0.))
+    if(auto s = interval.local_time_factor(tk); BOOST_LIKELY(s >= 0.))
     {
       auto max_tick = time_value{cst_max_dur - cst_old_date};
-      double diff = s * tick.impl - max_tick.impl;
+      double diff = interval.advance_for(tick, tk) - max_tick.impl;
       if(diff <= 0.)
       {
         if(tick != 0_tv)
-          interval.tick_offset(tick, offset, tk);
+          interval.tick_offset(tick, offset, tk, start_sample, window);
       }
       else
       {
+        // diff and max_tick are in the interval's frame, the cascade in ours.
+        const double sf = (s > 0.) ? s : 1.;
+        const int32_t cut = cut_at(max_tick.impl / sf);
+
         if(max_tick != 0_tv)
         {
-          interval.tick_offset_speed_precomputed(max_tick, offset, tk);
+          interval.tick_offset_speed_precomputed(
+              max_tick, offset, tk, start_sample, has_span ? cut - start_sample : -1);
         }
         else if(cst_max_dur == 0_tv)
         {
-          interval.tick_offset_speed_precomputed(max_tick, offset, tk);
+          interval.tick_offset_speed_precomputed(
+              max_tick, offset, tk, start_sample, has_span ? cut - start_sample : -1);
         }
 
-        const auto ot = ossia::time_value{int64_t(diff)};
+        const auto ot = ossia::time_value{int64_t(diff / sf)};
+        const auto next_offset = offset + ossia::time_value{int64_t(max_tick.impl / sf)};
+
         const auto node_it = m_overticks.lower_bound(end_node);
         if(node_it != m_overticks.end() && (end_node == node_it->first))
         {
@@ -178,39 +208,41 @@ void scenario::run_interval(
           if(ot > cur.max)
           {
             cur.max = ot;
-            cur.offset = tk.offset + tick_ms - cur.max;
+            cur.offset = next_offset;
+            cur.start_sample = cut;
           }
         }
         else
         {
-          m_overticks.insert(
-              node_it, {end_node, overtick{ot, ot, tk.offset + tick_ms - ot}});
+          m_overticks.insert(node_it, {end_node, overtick{ot, ot, next_offset, cut}});
         }
       }
     }
     else
     {
       // s < 0: interval has negative own speed (playing backwards locally)
-      auto backward_disp = int64_t(std::ceil(-tick.impl * s));
+      auto backward_disp = -interval.advance_for(tick, tk);
       if(backward_disp <= cst_old_date.impl)
       {
         if(tick != 0_tv)
-          interval.tick_offset(tick, offset, tk);
+          interval.tick_offset(tick, offset, tk, start_sample, window);
       }
       else
       {
-        // Clamp at zero
+        // Clamp at zero: only the samples that map to t >= 0 are covered.
         if(cst_old_date != 0_tv)
         {
+          const int32_t cut = cut_at(cst_old_date.impl / ((-s > 0.) ? -s : 1.));
           interval.tick_offset_speed_precomputed(
-              ossia::time_value{-cst_old_date.impl}, offset, tk);
+              ossia::time_value{-cst_old_date.impl}, offset, tk, start_sample,
+              has_span ? cut - start_sample : -1);
         }
       }
     }
   }
   else
   {
-    interval.tick_offset(tick, offset, tk);
+    interval.tick_offset(tick, offset, tk, start_sample, window);
   }
   if(interval.get_date() >= interval.get_min_duration())
   {
@@ -430,9 +462,17 @@ void scenario::state_impl(const ossia::token_request& tk)
       }
     }
 
+    // The window of the audio buffer this tick stands for, when known.
+    int32_t span_begin = -1, span_end = -1;
+    if(tk.start_sample >= 0 && tk.length_sample >= 0)
+    {
+      span_begin = tk.start_sample;
+      span_end = tk.start_sample + tk.length_sample;
+    }
+
     for(time_interval* interval : m_runningIntervals)
     {
-      run_interval(*interval, tk, tick_ms, tick_ms, tk.offset);
+      run_interval(*interval, tk, tick_ms, tick_ms, tk.offset, span_begin, span_end);
     }
 
     // Handle time syncs / events... if they are not finished, intervals in
@@ -458,9 +498,14 @@ void scenario::state_impl(const ossia::token_request& tk)
 
           const auto offset = tk.offset + tick_ms - remaining_tick;
           const_cast<overtick&>(it->second).offset = offset;
+
+          // What follows the sync starts writing at the sample the cut was
+          // taken at, and runs to the end of the parent's window.
+          const int32_t cut = it->second.start_sample;
+          const int32_t cut_end = cut >= 0 ? span_end : -1;
           for(const auto& interval : ev.next_time_intervals())
           {
-            run_interval(*interval, tk, tick_ms, remaining_tick, offset);
+            run_interval(*interval, tk, tick_ms, remaining_tick, offset, cut, cut_end);
           }
         }
       }
@@ -559,22 +604,25 @@ void scenario_graph::reset_component(time_sync& sync) const
 
 void scenario::run_interval_backward(
     ossia::time_interval& interval, const ossia::token_request& tk,
-    const time_value& tick_ms, ossia::time_value tick, ossia::time_value offset)
+    const time_value& tick_ms, ossia::time_value tick, ossia::time_value offset,
+    int32_t start_sample, int32_t end_sample)
 {
   const auto cst_old_date = interval.get_date();
 
-  // Nothing to do if already at 0
-  if(cst_old_date == 0_tv)
-    return;
-
   interval.set_parent_speed(tk.speed);
 
-  auto s = std::abs(interval.get_speed(interval.get_date()));
+  auto s = std::abs(interval.local_time_factor(tk));
   if(s == 0.)
     s = 1.0;
 
+  // The same inversion as forward: [start_sample; end_sample[ is the window
+  // of the audio buffer, and a cascade through an interval's start decides
+  // its cut in samples.
+  const bool has_span = start_sample >= 0 && end_sample >= start_sample;
+  const int32_t window = has_span ? end_sample - start_sample : -1;
+
   // How far backward do we move (positive amount)
-  auto displacement = int64_t(std::ceil(tick.impl * s));
+  auto displacement = interval.take_backward_step(tick, tk);
 
   if(displacement < cst_old_date.impl)
   {
@@ -582,23 +630,42 @@ void scenario::run_interval_backward(
     if(tick != 0_tv)
     {
       interval.tick_offset_speed_precomputed(
-          ossia::time_value{-displacement}, offset, tk);
+          ossia::time_value{-displacement}, offset, tk, start_sample, window);
     }
   }
   else
   {
-    // Would go past 0 - clamp at 0
+    // Would go past 0 - clamp at 0. The interval only stands for the part of
+    // the window it covers before reaching its start; the cascade continues
+    // from that sample.
+    int32_t cut = start_sample;
+    if(has_span && tick.impl > 0)
+    {
+      const double parent_time = cst_old_date.impl / s;
+      const auto c
+          = start_sample
+            + int32_t(std::llround(window * (parent_time / double(tick.impl))));
+      cut = c < start_sample ? start_sample : (c > end_sample ? end_sample : c);
+    }
+    else if(!has_span)
+    {
+      cut = -1;
+    }
+
     if(cst_old_date != 0_tv)
     {
       interval.tick_offset_speed_precomputed(
-          ossia::time_value{-cst_old_date.impl}, offset, tk);
+          ossia::time_value{-cst_old_date.impl}, offset, tk, start_sample,
+          has_span ? cut - start_sample : -1);
     }
 
     // Compute backward overtick (including start syncs, so the cascade
     // can reset the scenario to its initial state when rewinding to 0)
     const auto start_node = &interval.get_start_event().get_time_sync();
     {
-      const auto ot = ossia::time_value{displacement - cst_old_date.impl};
+      const auto ot = ossia::time_value{int64_t((displacement - cst_old_date.impl) / s)};
+
+      const auto ot_offset = offset + ossia::time_value{int64_t(cst_old_date.impl / s)};
 
       const auto node_it = m_backward_overticks.lower_bound(start_node);
       if(node_it != m_backward_overticks.end() && (start_node == node_it->first))
@@ -609,13 +676,14 @@ void scenario::run_interval_backward(
         if(ot > cur.max)
         {
           cur.max = ot;
-          cur.offset = offset;
+          cur.offset = ot_offset;
+          cur.start_sample = cut;
         }
       }
       else
       {
         m_backward_overticks.insert(
-            node_it, {start_node, overtick{ot, ot, offset}});
+            node_it, {start_node, overtick{ot, ot, ot_offset, cut}});
       }
 
       m_startNodes.insert(start_node);
@@ -632,10 +700,19 @@ void scenario::state_impl_backward(
 
   m_backward_overticks.reserve(m_nodes.size());
 
+  // The window of the audio buffer this tick stands for, when known.
+  int32_t span_begin = -1, span_end = -1;
+  if(tk.start_sample >= 0 && tk.length_sample >= 0)
+  {
+    span_begin = tk.start_sample;
+    span_end = tk.start_sample + tk.length_sample;
+  }
+
   // Tick all running intervals backward
   for(time_interval* interval : m_runningIntervals)
   {
-    run_interval_backward(*interval, tk, tick_amount, tick_amount, tk.offset);
+    run_interval_backward(
+        *interval, tk, tick_amount, tick_amount, tk.offset, span_begin, span_end);
   }
 
   // Backward cascade: when intervals reach date=0, transition to previous intervals
@@ -663,6 +740,8 @@ void scenario::state_impl_backward(
       const time_value remaining_tick
           = (mode == PROGRESS_MAX) ? ot_it->second.max : ot_it->second.min;
       const auto ot_offset = ot_it->second.offset;
+      const int32_t cut = ot_it->second.start_sample;
+      const int32_t cut_end = cut >= 0 ? span_end : -1;
 
       for(const auto& ev : sync_node->get_time_events())
       {
@@ -701,7 +780,8 @@ void scenario::state_impl_backward(
           m_runningIntervals.insert(prev_itv.get());
 
           // Tick the newly started interval with the remaining backward time
-          run_interval_backward(*prev_itv, tk, tick_amount, remaining_tick, ot_offset);
+          run_interval_backward(
+              *prev_itv, tk, tick_amount, remaining_tick, ot_offset, cut, cut_end);
         }
       }
     }
diff --git a/src/ossia/editor/scenario/scenario.hpp b/src/ossia/editor/scenario/scenario.hpp
index 5c05edc8c51..df30651e9b4 100644
--- a/src/ossia/editor/scenario/scenario.hpp
+++ b/src/ossia/editor/scenario/scenario.hpp
@@ -29,6 +29,10 @@ struct overtick
   ossia::time_value min;
   ossia::time_value max;
   ossia::time_value offset;
+
+  //! The sample of the audio buffer the cut was taken at: whatever follows
+  //! the sync starts writing there. -1 when the tick carried no sample span.
+  int32_t start_sample{-1};
 };
 using overtick_map = ossia::flat_map<time_sync*, overtick>;
 
@@ -224,9 +228,13 @@ class OSSIA_EXPORT scenario final : public looping_process<scenario>
   sync_status
   trigger_quantified_time_sync(time_sync& sync, bool& maximalDurationReached) noexcept;
 
+  //! [start_sample; end_sample[ is the window of the audio buffer this
+  //! dispatch stands for; when the interval ends inside it, the cut is
+  //! decided here, in samples, and everything after the sync starts from it.
   void run_interval(
       ossia::time_interval& interval, const ossia::token_request& tk,
-      const time_value& tick_ms, ossia::time_value tick, ossia::time_value offset);
+      const time_value& tick_ms, ossia::time_value tick, ossia::time_value offset,
+      int32_t start_sample, int32_t end_sample);
 
   void stop_interval(ossia::time_interval& itv);
   void reset_component(ossia::time_sync& n);
@@ -235,6 +243,7 @@ class OSSIA_EXPORT scenario final : public looping_process<scenario>
   void state_impl_backward(const ossia::token_request& tk, time_value tick_amount);
   void run_interval_backward(
       ossia::time_interval& interval, const ossia::token_request& tk,
-      const time_value& tick_ms, ossia::time_value tick, ossia::time_value offset);
+      const time_value& tick_ms, ossia::time_value tick, ossia::time_value offset,
+      int32_t start_sample, int32_t end_sample);
 };
 }
diff --git a/src/ossia/editor/scenario/time_interval.cpp b/src/ossia/editor/scenario/time_interval.cpp
index b0416168054..1f01ebcb833 100644
--- a/src/ossia/editor/scenario/time_interval.cpp
+++ b/src/ossia/editor/scenario/time_interval.cpp
@@ -87,13 +87,48 @@ void time_interval::tick_impl(
 
   // Clamp at zero: if speed is negative and we'd go below 0,
   // stay at 0 so we can resume instantly when speed becomes positive.
+  // The tick then only stands for the part of its samples that maps to
+  // t >= 0, so the carried span shrinks with the model dates.
   if(new_date < 0_tv)
   {
+    if(m_tick_length_sample > 0)
+    {
+      if(old_date > 0_tv)
+      {
+        const double covered
+            = double(old_date.impl) / double(old_date.impl - new_date.impl);
+        m_tick_length_sample = int32_t(m_tick_length_sample * covered + 0.5);
+      }
+      else
+      {
+        m_tick_length_sample = 0;
+      }
+    }
     new_date = 0_tv;
     m_date = 0_tv;
   }
   if(old_date < 0_tv)
+  {
+    // Mirror case, running forward out of negative territory: only the tail
+    // of the samples maps to t >= 0.
+    if(m_tick_length_sample > 0)
+    {
+      if(new_date > 0_tv)
+      {
+        const double covered
+            = double(new_date.impl) / double(new_date.impl - old_date.impl);
+        const auto kept = int32_t(m_tick_length_sample * covered + 0.5);
+        m_tick_start_sample += m_tick_length_sample - kept;
+        m_tick_length_sample = kept;
+      }
+      else
+      {
+        m_tick_start_sample += m_tick_length_sample;
+        m_tick_length_sample = 0;
+      }
+    }
     old_date = 0_tv;
+  }
 
   m_current_signature = signature(old_date, parent_request);
   m_current_tempo = m_speed * tempo(old_date, parent_request);
@@ -137,7 +172,7 @@ void time_interval::tick_impl(
       m_musical_start_position = num_quarters;
     }
 
-    if(new_date.impl > old_date.impl)
+    if(new_date.impl != old_date.impl)
     {
       auto d = ossia::time_value{new_date.impl};
       const double num_quarters = d.impl / m_quarter_duration;
@@ -177,21 +212,70 @@ void time_interval::tick_impl(
 void time_interval::tick_current(
     ossia::time_value offset, const ossia::token_request& parent_request)
 {
+  // A zero-length tick: it stands where the parent says, and for no samples.
+  m_tick_start_sample = parent_request.start_sample;
+  m_tick_length_sample = parent_request.length_sample >= 0 ? 0 : -1;
   tick_impl(m_date, m_date, offset, parent_request);
 }
 
 void time_interval::tick(
     time_value date, const ossia::token_request& parent_request, double ratio)
 {
+  // Driven directly (root of the tick tree): the whole of the parent's span.
+  m_tick_start_sample = parent_request.start_sample;
+  m_tick_length_sample = parent_request.length_sample;
   tick_impl(
-      m_date, m_date + std::ceil(date.impl * get_speed(m_date) / ratio), m_tick_offset,
+      m_date, m_date + take_step(date.impl * get_speed(m_date) / ratio), m_tick_offset,
       parent_request);
 }
 
+double time_interval::local_time_factor(
+    const ossia::token_request& parent_request) const noexcept
+{
+  if(BOOST_UNLIKELY(m_hasTempo && parent_request.speed != 0))
+    return (m_speed * tempo(m_date) / ossia::root_tempo) / parent_request.speed;
+  return m_speed;
+}
+
+ossia::time_value
+time_interval::to_local_offset(ossia::time_value offset, double factor) const noexcept
+{
+  if(offset.impl == 0)
+    return offset;
+  return ossia::time_value{int64_t(offset.impl * std::abs(factor))};
+}
+
+int64_t time_interval::take_step(double exact) noexcept
+{
+  const double want = exact + m_date_residue;
+  const double step = std::floor(want);
+  m_date_residue = want - step;
+  return int64_t(step);
+}
+
+int64_t time_interval::advance_for(
+    ossia::time_value date, const ossia::token_request& parent_request) const noexcept
+{
+  return int64_t(
+      std::floor(date.impl * local_time_factor(parent_request) + m_date_residue));
+}
+
+int64_t time_interval::take_backward_step(
+    ossia::time_value date, const ossia::token_request& parent_request) noexcept
+{
+  double f = std::abs(local_time_factor(parent_request));
+  if(f == 0.)
+    f = 1.;
+  return -take_step(-double(date.impl) * f);
+}
+
 void time_interval::tick_offset(
     time_value date, ossia::time_value offset,
-    const ossia::token_request& parent_request)
+    const ossia::token_request& parent_request, int32_t start_sample,
+    int32_t length_sample)
 {
+  m_tick_start_sample = start_sample;
+  m_tick_length_sample = length_sample;
 #if defined(OSSIA_SCENARIO_DATAFLOW)
   auto itv_node = static_cast<ossia::nodes::interval*>(node.get());
   int64_t seek_request = itv_node->seek;
@@ -216,19 +300,28 @@ void time_interval::tick_offset(
     // todo : this should be done outside for the scenario
     double speed = (m_speed * t0 / ossia::root_tempo) / parent_request.speed;
 
-    tick_impl(m_date, m_date + std::ceil(date.impl * speed), offset, parent_request);
+    tick_impl(
+        m_date, m_date + take_step(date.impl * speed), to_local_offset(offset, speed),
+        parent_request);
   }
   else
   {
-    tick_impl(m_date, m_date + std::ceil(date.impl * m_speed), offset, parent_request);
+    tick_impl(
+        m_date, m_date + take_step(date.impl * m_speed),
+        to_local_offset(offset, m_speed), parent_request);
   }
 }
 
 void time_interval::tick_offset_speed_precomputed(
     time_value date, ossia::time_value offset,
-    const ossia::token_request& parent_request)
+    const ossia::token_request& parent_request, int32_t start_sample,
+    int32_t length_sample)
 {
-  tick_impl(m_date, m_date + date.impl, offset, parent_request);
+  m_tick_start_sample = start_sample;
+  m_tick_length_sample = length_sample;
+  tick_impl(
+      m_date, m_date + date.impl,
+      to_local_offset(offset, local_time_factor(parent_request)), parent_request);
 }
 
 time_signature time_interval::signature(
@@ -322,6 +415,7 @@ void time_interval::start()
   // set clock at a tick
   m_running = true;
   m_date = m_offset;
+  m_date_residue = 0.;
 
   if(m_callback)
     (*m_callback)(true, m_date);
@@ -336,6 +430,7 @@ void time_interval::stop()
   }
 
   m_date = Zero;
+  m_date_residue = 0.;
   m_running = false;
   if(m_callback)
     (*m_callback)(false, m_date);
@@ -345,6 +440,7 @@ void time_interval::offset(ossia::time_value date)
 {
   m_offset = date;
   m_date = date;
+  m_date_residue = 0.;
 
   const auto& processes = get_time_processes();
   const auto N = processes.size();
@@ -367,6 +463,7 @@ void time_interval::transport(time_value date)
 {
   m_offset = date;
   m_date = date;
+  m_date_residue = 0.;
 
   const auto& processes = get_time_processes();
   const auto N = processes.size();
@@ -398,6 +495,8 @@ void time_interval::state(ossia::time_value from, ossia::time_value to)
     ossia::token_request tok{
         from,           to, m_nominal, m_tick_offset, m_globalSpeed, m_current_signature,
         m_current_tempo};
+    tok.start_sample = m_tick_start_sample;
+    tok.length_sample = m_tick_length_sample;
     tok.musical_start_last_signature = this->m_musical_start_last_signature;
     tok.musical_start_last_bar = this->m_musical_start_last_bar;
     tok.musical_start_position = this->m_musical_start_position;
diff --git a/src/ossia/editor/scenario/time_interval.hpp b/src/ossia/editor/scenario/time_interval.hpp
index b99a569ee00..554bdc994e4 100644
--- a/src/ossia/editor/scenario/time_interval.hpp
+++ b/src/ossia/editor/scenario/time_interval.hpp
@@ -57,6 +57,24 @@ class OSSIA_EXPORT time_interval
   double get_internal_speed() const noexcept { return m_speed; }
 
   double get_speed(time_value date) const noexcept;
+
+  //! The factor between the parent's model time and ours for this tick: the
+  //! same one the tick duration is scaled by. A tempo-locked interval runs at
+  //! its tempo whatever the transport does, hence the parent-speed division.
+  double local_time_factor(const ossia::token_request& parent_request) const noexcept;
+
+  //! How far a tick of this length would move us, in our own model time,
+  //! carried fraction included. This is what the tick actually advances by, so
+  //! anything deciding whether the tick fits must ask this and not recompute.
+  int64_t
+  advance_for(ossia::time_value, const ossia::token_request& parent_request) const noexcept;
+
+  //! How far back a rewinding scenario moves us, as a positive magnitude, the
+  //! carried fraction consumed the same way a forward tick consumes it so that
+  //! going out and back lands on the date we started from.
+  int64_t take_backward_step(
+      ossia::time_value, const ossia::token_request& parent_request) noexcept;
+
   void set_offset(ossia::time_value g) noexcept { m_offset = g; }
 
   void set_speed(double g) noexcept { m_speed = g; }
@@ -67,14 +85,23 @@ class OSSIA_EXPORT time_interval
   void
   tick_current(ossia::time_value offset, const ossia::token_request& parent_request);
 
+  //! Root driver tick: covers the parent request's whole carried sample span.
   void tick(
       ossia::time_value, const ossia::token_request& parent_request, double ratio = 1.0);
+
+  //! The span parameters are the samples of the audio buffer this tick stands
+  //! for, decided by the caller (the scenario cutting the buffer on interval
+  //! boundaries, or the root callback handing the whole buffer): they are
+  //! carried into the tokens verbatim, precisely because they cannot be
+  //! reconstructed from the flick-quantised model dates. -1 means unknown.
   void tick_offset(
       ossia::time_value, ossia::time_value offset,
-      const ossia::token_request& parent_request);
+      const ossia::token_request& parent_request, int32_t start_sample = -1,
+      int32_t length_sample = -1);
   void tick_offset_speed_precomputed(
       ossia::time_value, ossia::time_value offset,
-      const ossia::token_request& parent_request);
+      const ossia::token_request& parent_request, int32_t start_sample = -1,
+      int32_t length_sample = -1);
 
   /*! to get the interval execution back
    \param const #TimeValue position
@@ -230,6 +257,13 @@ class OSSIA_EXPORT time_interval
       ossia::time_value old_date, ossia::time_value new_date, ossia::time_value offset,
       const ossia::token_request& parent_request);
 
+  //! An offset is produced in the parent's frame but consumed in ours.
+  ossia::time_value
+  to_local_offset(ossia::time_value offset, double factor) const noexcept;
+
+  //! Consume the accumulated fraction and return the whole flicks to advance.
+  int64_t take_step(double exact) noexcept;
+
   std::vector<std::shared_ptr<time_process>> m_processes;
   time_interval::exec_callback m_callback;
 
@@ -245,6 +279,11 @@ class OSSIA_EXPORT time_interval
 
   time_value m_tick_offset{}; /// offset in the current tick
 
+  /// The samples of the audio buffer the current tick covers, as decided by
+  /// the caller of the tick; forwarded into the tokens handed to processes.
+  int32_t m_tick_start_sample{-1};
+  int32_t m_tick_length_sample{-1};
+
   double m_current_tempo{};
 
   time_signature_map m_timeSignature{};
@@ -261,6 +300,7 @@ class OSSIA_EXPORT time_interval
   ossia::quarter_note m_musical_end_position{};
 
   double m_speed{1.}; /// tick length is multiplied by this
+  double m_date_residue{}; /// sub-flick part of the advance, carried to the next tick
   double m_globalSpeed{1.};
   double m_parentSpeed{1.};
   time_signature m_current_signature{};
diff --git a/src/ossia/editor/scenario/time_value.hpp b/src/ossia/editor/scenario/time_value.hpp
index 1ecbe975545..46c2be2008b 100644
--- a/src/ossia/editor/scenario/time_value.hpp
+++ b/src/ossia/editor/scenario/time_value.hpp
@@ -52,11 +52,7 @@ struct OSSIA_EXPORT time_value
 
   constexpr time_value& operator+=(int64_t d) noexcept
   {
-    if(infinite())
-      impl = 0;
-    else
-      impl += d;
-
+    *this = *this + time_value{d};
     return *this;
   }
 
@@ -92,12 +88,9 @@ struct OSSIA_EXPORT time_value
     return *this;
   }
 
-  constexpr time_value& operator-() noexcept
+  [[nodiscard]] constexpr time_value operator-() const noexcept
   {
-    if(!infinite())
-      impl = -impl;
-
-    return *this;
+    return infinite() ? time_value{impl} : time_value{-impl};
   }
 
   /*! addition operator */
@@ -215,35 +208,36 @@ struct OSSIA_EXPORT time_value
     return time_value{impl - t.impl};
   }
 
-  /*! multiplication operator */
+  /*! multiplication operator. An infinite duration scaled by anything is still
+      infinite; without this it wraps to an arbitrary finite value. */
   constexpr time_value operator*(float d) const noexcept
   {
-    return time_value{int64_t(impl * d)};
+    return infinite() ? time_value{impl} : time_value{int64_t(impl * d)};
   }
 
   constexpr time_value operator*(double d) const noexcept
   {
-    return time_value{int64_t(impl * d)};
+    return infinite() ? time_value{impl} : time_value{int64_t(impl * d)};
   }
 
   constexpr time_value operator*(int32_t d) const noexcept
   {
-    return time_value{impl * d};
+    return infinite() ? time_value{impl} : time_value{impl * d};
   }
 
   constexpr time_value operator*(int64_t d) const noexcept
   {
-    return time_value{impl * d};
+    return infinite() ? time_value{impl} : time_value{impl * d};
   }
 
   constexpr time_value operator*(uint32_t d) const noexcept
   {
-    return time_value{impl * d};
+    return infinite() ? time_value{impl} : time_value{impl * d};
   }
 
   constexpr time_value operator*(uint64_t d) const noexcept
   {
-    return time_value{int64_t(impl * d)};
+    return infinite() ? time_value{impl} : time_value{int64_t(impl * d)};
   }
 
   friend constexpr double operator/(time_value lhs, time_value rhs) noexcept
@@ -274,13 +268,15 @@ struct OSSIA_EXPORT time_value
   {
     return !(infinite() && rhs.infinite()) && (impl > rhs.impl);
   }
+  // Two infinities compare equal, so they are also <= and >= each other;
+  // strict < and > stay false for them.
   constexpr bool operator<=(ossia::time_value rhs) const noexcept
   {
-    return !(infinite() && rhs.infinite()) && (impl <= rhs.impl);
+    return (infinite() && rhs.infinite()) || (impl <= rhs.impl);
   }
   constexpr bool operator>=(ossia::time_value rhs) const noexcept
   {
-    return !(infinite() && rhs.infinite()) && (impl >= rhs.impl);
+    return (infinite() && rhs.infinite()) || (impl >= rhs.impl);
   }
 
   int64_t impl;
diff --git a/src/ossia_setup.cmake b/src/ossia_setup.cmake
index 2908bd6fac6..96425faeb5f 100644
--- a/src/ossia_setup.cmake
+++ b/src/ossia_setup.cmake
@@ -55,6 +55,37 @@ if(WIN32)
     )
   endif()
 
+  target_compile_definitions(ossia PUBLIC
+    # Pin the Windows target for every translation unit, whatever the compiler.
+    #
+    # <windows.h> defines _WIN32_WINNT itself, through <sdkddkver.h>, whenever
+    # it is not already set, so leaving it alone does not mean "no minimum" - it
+    # means each TU gets one depending on whether it reached <windows.h> first.
+    # Asio reads it to decide BOOST_ASIO_HAS_STD_ATOMIC_WAIT, so two TUs here
+    # can disagree about which wait primitive it uses: an ODR violation that
+    # nothing reports, because both spellings mangle the same.
+    #
+    # The defaults also disagree between toolchains - the Windows Kits header
+    # picks 0x0A00, mingw-w64 picks _WIN32_WINNT_WS03 - so a mingw build has
+    # been configuring itself for Server 2003 wherever this was left alone.
+    #
+    # WINVER and NTDDI_VERSION are deliberately not set: sdkddkver.h derives
+    # WINVER from _WIN32_WINNT and NTDDI_VERSION from the SDK, so setting them
+    # by hand only creates a way for them to disagree.
+    _WIN32_WINNT=0x0A00
+
+    # And the version namespace, for the reasons in the top-level CMakeLists.
+    #
+    # PUBLIC because it is part of our ABI, not just of how we are built: the
+    # namespace is an inline namespace, so it is baked into the mangled name of
+    # every Asio type we expose. resolve_sync_v4 is explicitly instantiated
+    # here for boost::asio::ip::udp and ::tcp, and a consumer that does not
+    # agree about the namespace names a different specialisation and fails to
+    # link. Anything including our headers has to be configured the way we
+    # were.
+    BOOST_ASIO_ENABLE_VERSION_NAMESPACE=1
+  )
+
   if(NOT OSSIA_STATIC)
     target_compile_definitions(ossia
       PUBLIC
diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index 3cde00de9d1..6ebba487d37 100644
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -98,8 +98,20 @@ if(OSSIA_DATAFLOW)
   ossia_add_test(TickMethodTest              "${CMAKE_CURRENT_SOURCE_DIR}/Dataflow/TickMethodTest.cpp")
   ossia_add_test(TokenRequestTest            "${CMAKE_CURRENT_SOURCE_DIR}/Dataflow/TokenRequestTest.cpp")
   ossia_add_test(SoundTest                   "${CMAKE_CURRENT_SOURCE_DIR}/Dataflow/SoundTest.cpp")
+  ossia_add_test(BackwardPlaybackTest        "${CMAKE_CURRENT_SOURCE_DIR}/Dataflow/BackwardPlaybackTest.cpp")
+  ossia_add_test(BackwardAudioTest           "${CMAKE_CURRENT_SOURCE_DIR}/Dataflow/BackwardAudioTest.cpp")
+  ossia_add_test(TimingInvariantsTest        "${CMAKE_CURRENT_SOURCE_DIR}/Dataflow/TimingInvariantsTest.cpp")
   if(TARGET rubberband AND TARGET samplerate)
     target_link_libraries(ossia_SoundTest PRIVATE rubberband samplerate)
+    target_link_libraries(ossia_BackwardPlaybackTest PRIVATE rubberband samplerate)
+    target_link_libraries(ossia_BackwardAudioTest PRIVATE rubberband samplerate)
+  endif()
+endif()
+
+if(OSSIA_DATAFLOW)
+  ossia_add_test(SoundSyncTest               "${CMAKE_CURRENT_SOURCE_DIR}/Dataflow/SoundSyncTest.cpp")
+  if(TARGET rubberband AND TARGET samplerate)
+    target_link_libraries(ossia_SoundSyncTest PRIVATE rubberband samplerate)
   endif()
 endif()
 
diff --git a/tests/Dataflow/BackwardAudioTest.cpp b/tests/Dataflow/BackwardAudioTest.cpp
new file mode 100644
index 00000000000..d3d9b27ab90
--- /dev/null
+++ b/tests/Dataflow/BackwardAudioTest.cpp
@@ -0,0 +1,649 @@
+// Scenario-level tests for backwards playback (speed < 0).
+#include <ossia/detail/config.hpp>
+
+#include <ossia/dataflow/execution_state.hpp>
+#include <ossia/dataflow/graph/graph_static.hpp>
+#include <ossia/dataflow/graph_node.hpp>
+#include <ossia/dataflow/node_process.hpp>
+#include <ossia/dataflow/nodes/dummy.hpp>
+#include <ossia/dataflow/nodes/sound_ref.hpp>
+#include <ossia/dataflow/port.hpp>
+#include <ossia/editor/scenario/scenario.hpp>
+#include <ossia/editor/scenario/time_event.hpp>
+#include <ossia/editor/scenario/time_interval.hpp>
+#include <ossia/editor/scenario/time_sync.hpp>
+
+#include "include_catch.hpp"
+
+#include "../Editor/TestUtils.hpp"
+
+#include <algorithm>
+#include <vector>
+
+namespace
+{
+auto create_event(ossia::scenario& s)
+{
+  auto en = std::make_shared<ossia::time_sync>();
+  en->set_expression(ossia::expressions::make_expression_true());
+  auto ee = std::make_shared<ossia::time_event>(
+      ossia::time_event::exec_callback{}, *en,
+      ossia::expressions::make_expression_true());
+  en->insert(en->get_time_events().end(), ee);
+  s.add_time_sync(std::move(en));
+  return ee;
+}
+
+std::shared_ptr<ossia::time_interval> create_interval(
+    ossia::time_event& startEvent, ossia::time_event& endEvent, ossia::time_value d)
+{
+  auto ptr = ossia::time_interval::create({}, startEvent, endEvent, d, d, d);
+  ptr->add_time_process(std::make_shared<ossia::node_process>(
+      std::make_shared<ossia::nodes::dummy_node>()));
+  return ptr;
+}
+
+auto start_event(ossia::scenario& s)
+{
+  auto sn = s.get_start_time_sync();
+  return *sn->get_time_events().begin();
+}
+
+ossia::token_request default_request()
+{
+  ossia::token_request req;
+  req.tempo = 120;
+  req.speed = 1.;
+  req.signature = {4, 4};
+  return req;
+}
+
+void setup_state(ossia::execution_state& e, int bufferSize)
+{
+  e.bufferSize = bufferSize;
+  e.sampleRate = 48000;
+  e.modelToSamplesRatio = 48000. / ossia::flicks_per_second<double>;
+  e.samplesToModelRatio = ossia::flicks_per_second<double> / 48000.;
+}
+
+//! Records the buffer span every tick hands it, the way every audio plug-in
+//! node does.
+struct probe_node final : public ossia::graph_node
+{
+  struct span
+  {
+    int64_t start{}, frames{};
+    int64_t prev_date{}, date{};
+  };
+  std::vector<span> spans;
+
+  probe_node()
+  {
+    m_inlets.push_back(new ossia::audio_inlet);
+    m_outlets.push_back(new ossia::audio_outlet);
+  }
+  std::string label() const noexcept override { return "probe"; }
+
+  void run(const ossia::token_request& tk, ossia::exec_state_facade st) noexcept override
+  {
+    auto [start, frames] = st.timings(tk);
+    spans.push_back({start, frames, tk.prev_date.impl, tk.date.impl});
+  }
+};
+
+//! An audio effect the way CLAP / ysfx / avnd / (now) VST / VST3 / LV2 / faust
+//! do it: honour timings(), copy the span through.
+struct plugin_fx final : public ossia::nonowning_graph_node
+{
+  ossia::audio_inlet in;
+  ossia::audio_outlet out;
+  plugin_fx()
+  {
+    m_inlets.push_back(&in);
+    m_outlets.push_back(&out);
+  }
+  std::string label() const noexcept override { return "plugin_fx"; }
+
+  void run(const ossia::token_request& tk, ossia::exec_state_facade st) noexcept override
+  {
+    if(tk.paused())
+      return;
+    auto [start, frames] = st.timings(tk);
+    if(frames <= 0)
+      return;
+
+    auto& ip = *in;
+    auto& op = *out;
+    op.set_channels(std::max<std::size_t>(1, ip.channels()));
+    for(std::size_t c = 0; c < op.channels(); c++)
+    {
+      op.channel(c).resize(st.bufferSize());
+      if(c >= ip.channels())
+        continue;
+      ip.channel(c).resize(st.bufferSize());
+      for(int64_t i = start; i < start + frames; i++)
+        op.channel(c)[i] = ip.channel(c)[i];
+    }
+  }
+};
+
+//! Stands in for the interval / root nodes that keep ticking whatever the inner
+//! intervals do.
+struct sink_node final : public ossia::nonowning_graph_node
+{
+  ossia::audio_inlet in;
+  ossia::audio_outlet out;
+  std::vector<double> last;
+  sink_node()
+  {
+    m_inlets.push_back(&in);
+    m_outlets.push_back(&out);
+  }
+  std::string label() const noexcept override { return "sink"; }
+  void run(const ossia::token_request&, ossia::exec_state_facade) noexcept override
+  {
+    last.clear();
+    auto& ip = *in;
+    if(ip.channels() > 0)
+      for(auto v : ip.channel(0))
+        last.push_back(v);
+  }
+};
+
+//! The spans claimed on one tick must tile [0 ; bufferSize[ exactly.
+void require_exact_coverage(std::vector<probe_node::span> spans, int64_t bufferSize)
+{
+  std::sort(spans.begin(), spans.end(), [](const auto& a, const auto& b) {
+    return a.start < b.start;
+  });
+
+  int64_t expected = 0;
+  for(const auto& s : spans)
+  {
+    CAPTURE(s.start, s.frames, s.prev_date, s.date);
+    REQUIRE(s.frames > 0);
+    REQUIRE(s.start == expected);
+    expected = s.start + s.frames;
+  }
+  REQUIRE(expected == bufferSize);
+}
+}
+
+TEST_CASE("test_backward_after_score_end_is_silent",
+          "test_backward_after_score_end_is_silent")
+{
+  using namespace ossia;
+
+  // Intended behaviour: once the score has played to its end nothing is
+  // running any more, so there is nothing for the backward cascade to start
+  // from and rewinding does nothing. Pinned here so that widening the cascade
+  // - which now also handles intervals sitting at date 0 - cannot bring it
+  // back to life by accident.
+  constexpr int bs = 256;
+  execution_state e;
+  setup_state(e, bs);
+  const int64_t buffer_flicks = int64_t(bs * e.samplesToModelRatio);
+  const auto dur = ossia::time_value{2 * buffer_flicks};
+
+  root_scenario s;
+  std::vector<std::shared_ptr<time_event>> evs;
+  evs.push_back(start_event(*s.scenario));
+  for(int i = 0; i < 3; i++)
+    evs.push_back(create_event(*s.scenario));
+
+  std::vector<std::shared_ptr<probe_node>> probes;
+  for(int i = 0; i < 3; i++)
+  {
+    auto itv = create_interval(*evs[i], *evs[i + 1], dur);
+    s.scenario->add_time_interval(itv);
+    auto p = std::make_shared<probe_node>();
+    probes.push_back(p);
+    itv->add_time_process(std::make_shared<ossia::node_process>(p));
+  }
+
+  s.interval->start();
+  s.interval->tick_current(ossia::time_value{}, {});
+
+  auto tick = [&] {
+    int active = 0;
+    for(auto& p : probes)
+    {
+      p->requested_tokens.clear();
+      p->spans.clear();
+    }
+    s.interval->tick(ossia::time_value{buffer_flicks}, default_request());
+    for(auto& p : probes)
+    {
+      for(auto& tk : p->requested_tokens)
+        p->run(tk, {&e});
+      active += !p->spans.empty();
+    }
+    return active;
+  };
+
+  // Play the whole thing: 3 intervals of 2 buffers each.
+  for(int i = 0; i < 6; i++)
+  {
+    CAPTURE(i);
+    REQUIRE(tick() > 0);
+  }
+
+  // The score is over; rewinding does not restart it.
+  s.interval->set_speed(-1.);
+  for(int i = 0; i < 4; i++)
+  {
+    CAPTURE(i);
+    REQUIRE(tick() == 0);
+  }
+}
+
+TEST_CASE("test_backward_steady_state_timings", "test_backward_steady_state_timings")
+{
+  using namespace ossia;
+
+  constexpr int bs = 256;
+  execution_state e;
+  setup_state(e, bs);
+  const int64_t buffer_flicks = int64_t(bs * e.samplesToModelRatio);
+
+  root_scenario s;
+  auto se = start_event(*s.scenario);
+  auto ev1 = create_event(*s.scenario);
+  auto c0 = create_interval(*se, *ev1, ossia::time_value{200 * buffer_flicks});
+  s.scenario->add_time_interval(c0);
+
+  auto probe = std::make_shared<probe_node>();
+  c0->add_time_process(std::make_shared<ossia::node_process>(probe));
+
+  s.interval->start();
+  s.interval->tick_current(ossia::time_value{}, {});
+
+  auto do_tick = [&] {
+    probe->requested_tokens.clear();
+    s.interval->tick(ossia::time_value{buffer_flicks}, default_request());
+    for(auto& tk : probe->requested_tokens)
+      probe->run(tk, {&e});
+  };
+
+  for(int i = 0; i < 4; i++)
+    do_tick();
+  s.interval->set_speed(-1.);
+  for(int i = 0; i < 4; i++)
+    do_tick();
+
+  REQUIRE(probe->spans.size() == 8);
+
+  // Every tick, forward or backward, covers the whole buffer from its start.
+  for(std::size_t i = 0; i < probe->spans.size(); i++)
+  {
+    CAPTURE(i);
+    REQUIRE(probe->spans[i].start == 0);
+    REQUIRE(probe->spans[i].frames == bs);
+  }
+
+  // Forward the dates go up by one buffer, backward they come back down the
+  // same way, and the rewind lands exactly where the forward pass started.
+  for(int i = 0; i < 4; i++)
+  {
+    CAPTURE(i);
+    REQUIRE(probe->spans[i].date - probe->spans[i].prev_date == buffer_flicks);
+  }
+  for(int i = 4; i < 8; i++)
+  {
+    CAPTURE(i);
+    REQUIRE(probe->spans[i].prev_date - probe->spans[i].date == buffer_flicks);
+  }
+  REQUIRE(probe->spans[3].date == probe->spans[4].prev_date);
+  REQUIRE(probe->spans[7].date == 0);
+}
+
+TEST_CASE("test_backward_boundary_buffer_coverage", "test_backward_boundary_buffer_coverage")
+{
+  using namespace ossia;
+
+  constexpr int bs = 256;
+  execution_state e;
+  setup_state(e, bs);
+  const int64_t buffer_flicks = int64_t(bs * e.samplesToModelRatio);
+
+  // 2.5 buffers each, so both boundaries fall in the middle of a buffer.
+  const auto dur = ossia::time_value{5 * buffer_flicks / 2};
+
+  root_scenario s;
+  auto se = start_event(*s.scenario);
+  auto ev1 = create_event(*s.scenario);
+  auto ev2 = create_event(*s.scenario);
+  auto c0 = create_interval(*se, *ev1, dur);
+  s.scenario->add_time_interval(c0);
+  auto c1 = create_interval(*ev1, *ev2, dur);
+  s.scenario->add_time_interval(c1);
+
+  auto p0 = std::make_shared<probe_node>();
+  auto p1 = std::make_shared<probe_node>();
+  c0->add_time_process(std::make_shared<ossia::node_process>(p0));
+  c1->add_time_process(std::make_shared<ossia::node_process>(p1));
+
+  s.interval->start();
+  s.interval->tick_current(ossia::time_value{}, {});
+
+  // Returns the spans claimed on this tick, per interval.
+  auto do_tick = [&] {
+    p0->requested_tokens.clear();
+    p1->requested_tokens.clear();
+    p0->spans.clear();
+    p1->spans.clear();
+    s.interval->tick(ossia::time_value{buffer_flicks}, default_request());
+    for(auto& tk : p0->requested_tokens)
+      p0->run(tk, {&e});
+    for(auto& tk : p1->requested_tokens)
+      p1->run(tk, {&e});
+
+    std::vector<probe_node::span> all;
+    all.insert(all.end(), p0->spans.begin(), p0->spans.end());
+    all.insert(all.end(), p1->spans.begin(), p1->spans.end());
+    return all;
+  };
+
+  // ---- Forward: 4 ticks, the boundary lands inside tick 3.
+  int forward_boundary_ticks = 0;
+  for(int i = 0; i < 4; i++)
+  {
+    CAPTURE("forward", i);
+    const auto all = do_tick();
+    REQUIRE(!all.empty());
+    require_exact_coverage(all, bs);
+    if(all.size() == 2)
+    {
+      forward_boundary_ticks++;
+      // The interval that is earlier in the timeline gets the earlier part of
+      // the buffer.
+      REQUIRE(p0->spans.size() == 1);
+      REQUIRE(p1->spans.size() == 1);
+      REQUIRE(p0->spans[0].start == 0);
+      REQUIRE(p1->spans[0].start == p0->spans[0].frames);
+    }
+  }
+  REQUIRE(forward_boundary_ticks == 1);
+
+  // ---- Backward over the same ground.
+  s.interval->set_speed(-1.);
+  int backward_boundary_ticks = 0;
+  for(int i = 0; i < 4; i++)
+  {
+    CAPTURE("backward", i);
+    const auto all = do_tick();
+    REQUIRE(!all.empty());
+    require_exact_coverage(all, bs);
+    if(all.size() == 2)
+    {
+      backward_boundary_ticks++;
+      // Rewinding, the interval that is *later* in the timeline is the one
+      // heard first, so it takes the earlier part of the buffer.
+      REQUIRE(p0->spans.size() == 1);
+      REQUIRE(p1->spans.size() == 1);
+      REQUIRE(p1->spans[0].start == 0);
+      REQUIRE(p0->spans[0].start == p1->spans[0].frames);
+    }
+  }
+  REQUIRE(backward_boundary_ticks == 1);
+}
+
+TEST_CASE("test_backward_multiple_boundaries_in_one_buffer",
+          "test_backward_multiple_boundaries_in_one_buffer")
+{
+  using namespace ossia;
+
+  // Intervals shorter than a buffer, so a single tick crosses several of them
+  // and the overtick cascades more than once. Each cascade narrows the tick it
+  // hands down, so the buffer offset has to be derived from the whole tick and
+  // not from the already-narrowed one.
+  constexpr int bs = 256;
+  constexpr int n_itv = 6;
+  execution_state e;
+  setup_state(e, bs);
+  const int64_t buffer_flicks = int64_t(bs * e.samplesToModelRatio);
+  // 3/8th of a buffer each: one tick crosses two boundaries and stops inside
+  // the third interval, in both directions.
+  const auto dur = ossia::time_value{3 * buffer_flicks / 8};
+
+  root_scenario s;
+  std::vector<std::shared_ptr<time_event>> evs;
+  evs.push_back(start_event(*s.scenario));
+  for(int i = 0; i < n_itv; i++)
+    evs.push_back(create_event(*s.scenario));
+
+  std::vector<std::shared_ptr<probe_node>> probes;
+  for(int i = 0; i < n_itv; i++)
+  {
+    auto itv = create_interval(*evs[i], *evs[i + 1], dur);
+    s.scenario->add_time_interval(itv);
+    auto p = std::make_shared<probe_node>();
+    probes.push_back(p);
+    itv->add_time_process(std::make_shared<ossia::node_process>(p));
+  }
+
+  s.interval->start();
+  s.interval->tick_current(ossia::time_value{}, {});
+
+  auto do_tick = [&] {
+    std::vector<probe_node::span> all;
+    for(auto& p : probes)
+    {
+      p->requested_tokens.clear();
+      p->spans.clear();
+    }
+    s.interval->tick(ossia::time_value{buffer_flicks}, default_request());
+    for(auto& p : probes)
+    {
+      for(auto& tk : p->requested_tokens)
+        p->run(tk, {&e});
+      all.insert(all.end(), p->spans.begin(), p->spans.end());
+    }
+    return all;
+  };
+
+  // One forward buffer covers four of the six intervals.
+  {
+    const auto all = do_tick();
+    CAPTURE(all.size());
+    REQUIRE(all.size() >= 3);
+    require_exact_coverage(all, bs);
+  }
+
+  // Rewind over the same ground: the boundaries must tile the buffer just the
+  // same. This is where using the narrowed tick as the base put every interval
+  // after the first cascade at the wrong buffer position.
+  s.interval->set_speed(-1.);
+  {
+    const auto all = do_tick();
+    CAPTURE(all.size());
+    REQUIRE(all.size() >= 3);
+    require_exact_coverage(all, bs);
+  }
+}
+
+TEST_CASE("test_backward_audio_is_reversed_stream", "test_backward_audio_is_reversed_stream")
+{
+  using namespace ossia;
+
+  constexpr int bs = 8;
+  execution_state e;
+  setup_state(e, bs);
+  const int64_t buffer_flicks = int64_t(bs * e.samplesToModelRatio);
+
+  // A 64-sample ramp holding 1..64, so an output sample tells us which file
+  // sample it came from.
+  ossia::audio_array data;
+  data.resize(1);
+  data[0].resize(64);
+  for(int i = 0; i < 64; i++)
+    data[0][i] = float(i + 1);
+
+  auto snd = std::make_shared<ossia::nodes::sound_ref>();
+  snd->set_sound(data);
+  auto fx = std::make_shared<plugin_fx>();
+  auto sink = std::make_shared<sink_node>();
+
+  ossia::tc_graph g;
+  g.add_node(snd);
+  g.add_node(fx);
+  g.add_node(sink);
+  g.connect(g.allocate_edge(
+      ossia::immediate_glutton_connection{}, &snd->audio_out, &fx->in, snd, fx));
+  g.connect(g.allocate_edge(
+      ossia::immediate_glutton_connection{}, &fx->out, &sink->in, fx, sink));
+
+  root_scenario s;
+  auto se = start_event(*s.scenario);
+  auto ev1 = create_event(*s.scenario);
+  auto c0 = create_interval(*se, *ev1, ossia::time_value{8 * buffer_flicks});
+  s.scenario->add_time_interval(c0);
+  c0->add_time_process(std::make_shared<ossia::node_process>(snd));
+  c0->add_time_process(std::make_shared<ossia::node_process>(fx));
+  s.interval->add_time_process(std::make_shared<ossia::node_process>(sink));
+
+  s.interval->start();
+  s.interval->tick_current(ossia::time_value{}, {});
+
+  std::vector<std::vector<double>> buffers;
+  auto do_tick = [&] {
+    e.begin_tick();
+    s.interval->tick(ossia::time_value{buffer_flicks}, default_request());
+    g.state(e);
+    e.commit();
+    buffers.push_back(sink->last);
+  };
+
+  for(int i = 0; i < 5; i++)
+    do_tick();
+  s.interval->set_speed(-1.);
+  for(int i = 0; i < 5; i++)
+    do_tick();
+
+  REQUIRE(buffers.size() == 10);
+  for(std::size_t i = 0; i < buffers.size(); i++)
+  {
+    CAPTURE(i);
+    REQUIRE(buffers[i].size() == bs);
+  }
+
+  // Forward, steady state: buffer n holds file samples 8n+1 .. 8n+8.
+  // (buffer 0 is faded in - the interval just started - so it is checked
+  // separately below.)
+  for(int b = 1; b < 5; b++)
+  {
+    for(int i = 0; i < bs; i++)
+    {
+      CAPTURE(b, i);
+      REQUIRE(buffers[b][i] == Catch::Approx(double(b * bs + i + 1)));
+    }
+  }
+
+  // Backward, steady state: the exact same samples, in reverse. Buffer 5 is the
+  // direction change itself, buffer 9 hits the start of the interval and is
+  // faded out, so the unambiguous ones are 6, 7, 8.
+  const double expected_first[3] = {33., 25., 17.};
+  for(int b = 6; b <= 8; b++)
+  {
+    for(int i = 0; i < bs; i++)
+    {
+      CAPTURE(b, i);
+      REQUIRE(buffers[b][i] == Catch::Approx(expected_first[b - 6] - i));
+    }
+  }
+
+  // The stream is continuous across the buffer boundaries: the last sample of
+  // one buffer is followed by its predecessor.
+  for(int b = 6; b <= 8; b++)
+  {
+    CAPTURE(b);
+    REQUIRE(buffers[b][0] == Catch::Approx(buffers[b - 1][bs - 1] - 1.));
+  }
+
+  // Direction change: buffer 5 is still strictly descending by one sample.
+  for(int i = 1; i < bs; i++)
+  {
+    CAPTURE(i);
+    REQUIRE(buffers[5][i] == Catch::Approx(buffers[5][i - 1] - 1.));
+  }
+
+  // Fades: the first and last buffers are attenuated versions of the ramp, so
+  // they must stay bounded by it and never be silent all through.
+  for(int b : {0, 9})
+  {
+    bool any = false;
+    for(int i = 0; i < bs; i++)
+    {
+      CAPTURE(b, i);
+      REQUIRE(std::abs(buffers[b][i]) <= 64.);
+      any |= buffers[b][i] != 0.;
+    }
+    REQUIRE(any);
+  }
+}
+
+TEST_CASE("test_backward_audio_plugin_is_not_silent", "test_backward_audio_plugin_is_not_silent")
+{
+  using namespace ossia;
+
+  // The shared execution path must keep handing a node real work to do while
+  // the timeline runs backwards.
+  constexpr int bs = 8;
+  execution_state e;
+  setup_state(e, bs);
+  const int64_t buffer_flicks = int64_t(bs * e.samplesToModelRatio);
+
+  ossia::audio_array data;
+  data.resize(1);
+  data[0].resize(64);
+  for(int i = 0; i < 64; i++)
+    data[0][i] = 1.f;
+
+  auto snd = std::make_shared<ossia::nodes::sound_ref>();
+  snd->set_sound(data);
+  auto fx = std::make_shared<plugin_fx>();
+  auto sink = std::make_shared<sink_node>();
+
+  ossia::tc_graph g;
+  g.add_node(snd);
+  g.add_node(fx);
+  g.add_node(sink);
+  g.connect(g.allocate_edge(
+      ossia::immediate_glutton_connection{}, &snd->audio_out, &fx->in, snd, fx));
+  g.connect(g.allocate_edge(
+      ossia::immediate_glutton_connection{}, &fx->out, &sink->in, fx, sink));
+
+  root_scenario s;
+  auto se = start_event(*s.scenario);
+  auto ev1 = create_event(*s.scenario);
+  auto c0 = create_interval(*se, *ev1, ossia::time_value{8 * buffer_flicks});
+  s.scenario->add_time_interval(c0);
+  c0->add_time_process(std::make_shared<ossia::node_process>(snd));
+  c0->add_time_process(std::make_shared<ossia::node_process>(fx));
+  s.interval->add_time_process(std::make_shared<ossia::node_process>(sink));
+
+  s.interval->start();
+  s.interval->tick_current(ossia::time_value{}, {});
+
+  auto do_tick = [&] {
+    e.begin_tick();
+    s.interval->tick(ossia::time_value{buffer_flicks}, default_request());
+    g.state(e);
+    e.commit();
+  };
+
+  for(int i = 0; i < 4; i++)
+    do_tick();
+
+  s.interval->set_speed(-1.);
+  for(int i = 0; i < 3; i++)
+  {
+    CAPTURE(i);
+    do_tick();
+    REQUIRE(sink->last.size() == bs);
+    double sum = 0.;
+    for(double v : sink->last)
+      sum += std::abs(v);
+    REQUIRE(sum > 0.);
+  }
+}
diff --git a/tests/Dataflow/BackwardPlaybackTest.cpp b/tests/Dataflow/BackwardPlaybackTest.cpp
new file mode 100644
index 00000000000..ae5bb4abc49
--- /dev/null
+++ b/tests/Dataflow/BackwardPlaybackTest.cpp
@@ -0,0 +1,729 @@
+// Unit tests for backwards playback (speed < 0).
+#include <ossia/detail/config.hpp>
+
+#include <ossia/dataflow/execution_state.hpp>
+#include <ossia/dataflow/nodes/sound.hpp>
+#include <ossia/dataflow/token_request.hpp>
+#include <ossia/editor/scenario/time_value.hpp>
+
+#include "include_catch.hpp"
+
+#include <optional>
+#include <tuple>
+#include <vector>
+
+namespace
+{
+// 1 model unit == 1 sample, which keeps the expected values readable.
+constexpr double unit_ratio = 1.;
+
+ossia::token_request
+tick(int64_t prev, int64_t date, int64_t offset, double speed) noexcept
+{
+  return ossia::token_request{
+      ossia::time_value{prev},   ossia::time_value{date}, ossia::time_value{1000000},
+      ossia::time_value{offset}, speed,                   ossia::time_signature{4, 4},
+      120.};
+}
+}
+
+TEST_CASE("test_time_value_unary_minus_is_pure", "test_time_value_unary_minus_is_pure")
+{
+  ossia::time_value v{200};
+  const auto n = -v;
+
+  REQUIRE(n.impl == -200);
+  REQUIRE(v.impl == 200);
+
+  // Two negations in the same expression must not interfere.
+  ossia::time_value a{7};
+  ossia::time_value b{5};
+  REQUIRE((-a + -b).impl == -12);
+  REQUIRE(a.impl == 7);
+  REQUIRE(b.impl == 5);
+
+  // Infinity stays infinite.
+  ossia::time_value inf{ossia::time_value::infinity};
+  REQUIRE((-inf).infinite());
+  REQUIRE(inf.infinite());
+
+  // And it is usable on a const time_value / a temporary.
+  const ossia::time_value c{42};
+  REQUIRE((-c).impl == -42);
+  REQUIRE((-ossia::time_value{3}).impl == -3);
+}
+
+TEST_CASE("test_physical_helpers_are_direction_symmetric",
+          "test_physical_helpers_are_direction_symmetric")
+{
+  constexpr int bufferSize = 512;
+
+  struct
+  {
+    const char* name;
+    double speed;
+    int64_t dt;
+  } speeds[] = {
+      {"x1", 1., 200},   {"-x1", -1., 200},   {"x2", 2., 400},
+      {"-x2", -2., 400}, {"x0.5", 0.5, 100},  {"-x0.5", -0.5, 100},
+  };
+
+  for(auto& s : speeds)
+  {
+    const int64_t offset = 100;
+    const auto t = s.speed > 0 ? tick(1000, 1000 + s.dt, offset, s.speed)
+                               : tick(1000 + s.dt, 1000, offset, s.speed);
+
+    const auto abs_speed = s.speed < 0 ? -s.speed : s.speed;
+    const auto expected_start = int64_t(offset / abs_speed);
+    const auto expected_len = int64_t(s.dt / abs_speed);
+
+    CAPTURE(s.name);
+    REQUIRE(t.physical_start(unit_ratio) == expected_start);
+    REQUIRE(t.physical_write_duration(unit_ratio) == expected_len);
+    REQUIRE(t.physical_read_duration(unit_ratio) == s.dt);
+    REQUIRE(
+        t.safe_physical_write_duration(unit_ratio, bufferSize)
+        == bufferSize - expected_start);
+
+    // Never negative, whichever way we go.
+    REQUIRE(t.physical_start(unit_ratio) >= 0);
+    REQUIRE(t.physical_write_duration(unit_ratio) >= 0);
+    REQUIRE(t.safe_physical_write_duration(unit_ratio, bufferSize) >= 0);
+  }
+}
+
+TEST_CASE("test_to_physical_time_in_tick_both_directions",
+          "test_to_physical_time_in_tick_both_directions")
+{
+  {
+    // Forward: prev_date -> start of the span, date -> end of it.
+    const auto t = tick(1000, 1200, 100, 1.);
+    REQUIRE(t.to_physical_time_in_tick(ossia::time_value{1000}, unit_ratio) == 100);
+    REQUIRE(t.to_physical_time_in_tick(ossia::time_value{1100}, unit_ratio) == 200);
+    REQUIRE(t.to_physical_time_in_tick(ossia::time_value{1200}, unit_ratio) == 300);
+    REQUIRE(
+        t.to_physical_time_in_tick(t.prev_date, unit_ratio)
+        == t.physical_start(unit_ratio));
+    REQUIRE(
+        t.to_physical_time_in_tick(t.date, unit_ratio)
+        == t.physical_start(unit_ratio) + t.physical_write_duration(unit_ratio));
+  }
+
+  {
+    // Backward: same span, prev_date is still the first sample written.
+    const auto t = tick(1200, 1000, 100, -1.);
+    REQUIRE(t.to_physical_time_in_tick(ossia::time_value{1200}, unit_ratio) == 100);
+    REQUIRE(t.to_physical_time_in_tick(ossia::time_value{1100}, unit_ratio) == 200);
+    REQUIRE(t.to_physical_time_in_tick(ossia::time_value{1000}, unit_ratio) == 300);
+    REQUIRE(
+        t.to_physical_time_in_tick(t.prev_date, unit_ratio)
+        == t.physical_start(unit_ratio));
+    REQUIRE(
+        t.to_physical_time_in_tick(t.date, unit_ratio)
+        == t.physical_start(unit_ratio) + t.physical_write_duration(unit_ratio));
+  }
+
+  {
+    // Monotonically increasing in buffer position as the playhead advances,
+    // in both directions.
+    const auto fwd = tick(1000, 1200, 0, 1.);
+    const auto bwd = tick(1200, 1000, 0, -1.);
+    int64_t prev_f = -1, prev_b = -1;
+    for(int64_t i = 0; i <= 200; i++)
+    {
+      const auto f = fwd.to_physical_time_in_tick(ossia::time_value{1000 + i}, unit_ratio);
+      const auto b = bwd.to_physical_time_in_tick(ossia::time_value{1200 - i}, unit_ratio);
+      REQUIRE(f > prev_f);
+      REQUIRE(b > prev_b);
+      REQUIRE(f == b);
+      prev_f = f;
+      prev_b = b;
+    }
+  }
+}
+
+TEST_CASE("test_physical_time_roundtrip", "test_physical_time_roundtrip")
+{
+  const ossia::token_request ticks[] = {
+      tick(1000, 1200, 0, 1.),   tick(1200, 1000, 0, -1.),
+      tick(1000, 1200, 100, 1.), tick(1200, 1000, 100, -1.),
+      tick(1000, 1400, 100, 2.), tick(1400, 1000, 100, -2.),
+  };
+
+  for(const auto& t : ticks)
+  {
+    CAPTURE(t.prev_date.impl, t.date.impl, t.offset.impl, t.speed);
+    const auto start = t.physical_start(unit_ratio);
+    const auto len = t.physical_write_duration(unit_ratio);
+    for(int64_t s = start; s <= start + len; s++)
+    {
+      const auto model = t.from_physical_time_in_tick(s, unit_ratio);
+      REQUIRE(t.to_physical_time_in_tick(model, unit_ratio) == s);
+    }
+  }
+}
+
+namespace
+{
+struct loop_result
+{
+  std::vector<ossia::token_request> subs;
+  std::vector<int64_t> transports;
+};
+
+loop_result run_loop(
+    int64_t from, int64_t to, int64_t start_offset, int64_t loop_duration,
+    int64_t initial_offset = 0)
+{
+  loop_result res;
+  const auto t = tick(from, to, initial_offset, to >= from ? 1. : -1.);
+  t.loop(
+      ossia::time_value{start_offset}, ossia::time_value{loop_duration},
+      [&](const ossia::token_request& sub) {
+    // Guard against a runaway subdivision rather than filling memory.
+    if(res.subs.size() < 64)
+      res.subs.push_back(sub);
+      },
+      [&](const ossia::time_value& d) { res.transports.push_back(d.impl); });
+  return res;
+}
+
+//! Invariants that must hold for every loop() subdivision, both directions.
+void check_loop(
+    int64_t from, int64_t to, int64_t start_offset, int64_t loop_duration,
+    int64_t expected_subs)
+{
+  CAPTURE(from, to, start_offset, loop_duration);
+  const auto res = run_loop(from, to, start_offset, loop_duration);
+
+  REQUIRE(res.subs.size() == std::size_t(expected_subs));
+
+  const int64_t requested = to - from;
+  int64_t emitted = 0;
+  int64_t expected_offset = 0;
+
+  for(std::size_t i = 0; i < res.subs.size(); i++)
+  {
+    const auto& sub = res.subs[i];
+    const int64_t dt = (sub.date - sub.prev_date).impl;
+    CAPTURE(i, sub.prev_date.impl, sub.date.impl, dt, sub.offset.impl);
+
+    // The direction of each piece matches the direction of the request.
+    REQUIRE((dt < 0) == (requested < 0));
+    REQUIRE(dt != 0);
+
+    // Every piece stays inside the loop.
+    REQUIRE(sub.prev_date.impl >= start_offset);
+    REQUIRE(sub.prev_date.impl <= start_offset + loop_duration);
+    REQUIRE(sub.date.impl >= start_offset);
+    REQUIRE(sub.date.impl <= start_offset + loop_duration);
+
+    // The pieces tile the buffer contiguously.
+    REQUIRE(sub.offset.impl == expected_offset);
+    expected_offset += dt < 0 ? -dt : dt;
+
+    emitted += dt;
+  }
+
+  // Nothing lost, nothing invented.
+  REQUIRE(emitted == requested);
+}
+}
+
+TEST_CASE("test_loop_subdivision_forward", "test_loop_subdivision_forward")
+{
+  check_loop(2600, 2900, 0, 1000, 1);    // inside one iteration
+  check_loop(2900, 3200, 0, 1000, 2);    // crosses the loop point
+  check_loop(3000, 3100, 0, 1000, 1);    // starts on the loop point
+  check_loop(500, 2500, 0, 1000, 3);     // crosses two loop points
+  check_loop(2600, 2900, 5000, 1000, 1); // with a start offset
+  check_loop(2900, 3200, 5000, 1000, 2);
+}
+
+TEST_CASE("test_loop_subdivision_backward", "test_loop_subdivision_backward")
+{
+  check_loop(2900, 2600, 0, 1000, 1);    // inside one iteration
+  check_loop(3200, 2900, 0, 1000, 2);    // crosses the loop point
+  check_loop(3100, 3000, 0, 1000, 1);    // lands exactly on the loop point
+  check_loop(3000, 2900, 0, 1000, 1);    // starts exactly on the loop point
+  check_loop(2500, 500, 0, 1000, 3);     // crosses two loop points
+  check_loop(2900, 2600, 5000, 1000, 1); // with a start offset
+  check_loop(3200, 2900, 5000, 1000, 2);
+}
+
+TEST_CASE("test_loop_subdivision_backward_values", "test_loop_subdivision_backward_values")
+{
+  {
+    // 3200 -> 2900 with a 1000-long loop: 200 units back to the loop start,
+    // then the last 100 taken from the end of the previous iteration.
+    const auto res = run_loop(3200, 2900, 0, 1000);
+    REQUIRE(res.subs.size() == 2);
+
+    REQUIRE(res.subs[0].prev_date.impl == 200);
+    REQUIRE(res.subs[0].date.impl == 0);
+    REQUIRE(res.subs[0].offset.impl == 0);
+
+    REQUIRE(res.subs[1].prev_date.impl == 1000);
+    REQUIRE(res.subs[1].date.impl == 900);
+    REQUIRE(res.subs[1].offset.impl == 200);
+
+    // The source must be repositioned to the loop end before the second piece.
+    REQUIRE(res.transports.size() == 1);
+    REQUIRE(res.transports[0] == 1000);
+  }
+
+  {
+    // Sitting exactly on the loop start: rewinding enters the previous
+    // iteration from its end, so a transport happens before anything is played.
+    const auto res = run_loop(3000, 2900, 0, 1000);
+    REQUIRE(res.subs.size() == 1);
+    REQUIRE(res.subs[0].prev_date.impl == 1000);
+    REQUIRE(res.subs[0].date.impl == 900);
+    REQUIRE(res.transports.size() == 1);
+    REQUIRE(res.transports[0] == 1000);
+  }
+
+  {
+    // With a start offset, the emitted dates are shifted by it.
+    const auto res = run_loop(3200, 2900, 10000, 1000);
+    REQUIRE(res.subs.size() == 2);
+    REQUIRE(res.subs[0].prev_date.impl == 10200);
+    REQUIRE(res.subs[0].date.impl == 10000);
+    REQUIRE(res.subs[1].prev_date.impl == 11000);
+    REQUIRE(res.subs[1].date.impl == 10900);
+    REQUIRE(res.transports.size() == 1);
+    REQUIRE(res.transports[0] == 11000);
+  }
+}
+
+TEST_CASE("test_loop_no_duration", "test_loop_no_duration")
+{
+  // A zero / negative loop duration means "no looping": one sub-request,
+  // shifted by the start offset, in both directions.
+  for(int64_t dur : {int64_t(0), int64_t(-1)})
+  {
+    {
+      const auto res = run_loop(1000, 1200, 50, dur);
+      REQUIRE(res.subs.size() == 1);
+      REQUIRE(res.subs[0].prev_date.impl == 1050);
+      REQUIRE(res.subs[0].date.impl == 1250);
+    }
+    {
+      const auto res = run_loop(1200, 1000, 50, dur);
+      REQUIRE(res.subs.size() == 1);
+      REQUIRE(res.subs[0].prev_date.impl == 1250);
+      REQUIRE(res.subs[0].date.impl == 1050);
+    }
+  }
+}
+
+TEST_CASE("test_sound_sample_info_partial_ticks", "test_sound_sample_info_partial_ticks")
+{
+  constexpr int64_t bufferSize = 256;
+
+  // A full tick fills the whole buffer, both directions.
+  {
+    const auto f = ossia::snd::sample_info(bufferSize, unit_ratio, tick(0, 256, 0, 1.));
+    REQUIRE(f.samples_to_write == 256);
+    const auto b = ossia::snd::sample_info(bufferSize, unit_ratio, tick(256, 0, 0, -1.));
+    REQUIRE(b.samples_to_write == 256);
+  }
+
+  // An interval *ending* mid-buffer must write only its own part of it: it used
+  // to write all the way to the end of the buffer, over the samples belonging
+  // to whatever starts playing next, and drift its read position by the
+  // difference on every such tick.
+  {
+    const auto f = ossia::snd::sample_info(bufferSize, unit_ratio, tick(0, 128, 0, 1.));
+    REQUIRE(f.samples_to_write == 128);
+    const auto b = ossia::snd::sample_info(bufferSize, unit_ratio, tick(128, 0, 0, -1.));
+    REQUIRE(b.samples_to_write == 128);
+  }
+
+  // An interval *starting* mid-buffer writes the second half.
+  {
+    const auto f = ossia::snd::sample_info(bufferSize, unit_ratio, tick(0, 128, 128, 1.));
+    REQUIRE(f.samples_to_write == 128);
+    const auto b
+        = ossia::snd::sample_info(bufferSize, unit_ratio, tick(128, 0, 128, -1.));
+    REQUIRE(b.samples_to_write == 128);
+  }
+
+  // Never more than what is left in the buffer.
+  {
+    const auto f = ossia::snd::sample_info(bufferSize, unit_ratio, tick(0, 512, 200, 1.));
+    REQUIRE(f.samples_to_write == bufferSize - 200);
+    const auto b
+        = ossia::snd::sample_info(bufferSize, unit_ratio, tick(512, 0, 200, -1.));
+    REQUIRE(b.samples_to_write == bufferSize - 200);
+  }
+
+  // A paused tick reads and writes nothing.
+  {
+    const auto p = ossia::snd::sample_info(bufferSize, unit_ratio, tick(128, 128, 0, 1.));
+    REQUIRE(p.samples_to_write == 0);
+    REQUIRE(p.samples_to_read == 0);
+  }
+}
+
+namespace
+{
+//! A tick carrying musical positions, the way time_interval::tick_impl fills
+//! them in. 4/4, bar and signature change at quarter 0.
+ossia::token_request musical_tick(
+    int64_t prev, int64_t date, double musical_start, double musical_end,
+    int64_t offset = 0)
+{
+  auto t = tick(prev, date, offset, date >= prev ? 1. : -1.);
+  t.musical_start_last_signature = 0.;
+  t.musical_start_last_bar = 0.;
+  t.musical_start_position = musical_start;
+  t.musical_end_last_bar = 0.;
+  t.musical_end_position = musical_end;
+  return t;
+}
+}
+
+TEST_CASE("test_quantification_dates_backward", "test_quantification_dates_backward")
+{
+  // One quarter note per tick, sixteenth-note division: four steps.
+  const auto fwd = musical_tick(0, 1000, 0., 1.);
+  const auto bwd = musical_tick(1000, 0, 1., 0.);
+
+  const auto f = fwd.get_quantification_dates(16.);
+  const auto b = bwd.get_quantification_dates(16.);
+
+  REQUIRE(f.size() == 4);
+  REQUIRE(b.size() == 4);
+
+  // Forward covers [start; end[ : quarters 0, 1/4, 1/2, 3/4.
+  const int64_t expected_f[4] = {0, 250, 500, 750};
+  for(int i = 0; i < 4; i++)
+  {
+    CAPTURE(i);
+    REQUIRE(f[i].date.impl == expected_f[i]);
+  }
+
+  // Rewinding covers the mirror interval ]end; start] : quarters 1, 3/4, 1/2,
+  // 1/4, reported from the top so that the buffer positions increase.
+  const int64_t expected_b[4] = {1000, 750, 500, 250};
+  for(int i = 0; i < 4; i++)
+  {
+    CAPTURE(i);
+    REQUIRE(b[i].date.impl == expected_b[i]);
+    if(i > 0)
+      REQUIRE(b[i].date < b[i - 1].date);
+    REQUIRE(
+        bwd.to_physical_time_in_tick(b[i].date, unit_ratio) == int64_t(i) * 250);
+  }
+
+  // The step indices count the same points, in the opposite order.
+  REQUIRE(f[0].index == 0);
+  REQUIRE(f[3].index == 3);
+  REQUIRE(b[0].index == 4);
+  REQUIRE(b[3].index == 1);
+}
+
+TEST_CASE("test_quantification_dates_backward_no_spurious_step",
+          "test_quantification_dates_backward_no_spurious_step")
+{
+  // A tick shorter than the division reports nothing.
+  const auto bwd = musical_tick(1000, 900, 0.95, 0.85);
+  REQUIRE(bwd.get_quantification_dates(4.).empty());
+
+  // And a tick spanning exactly one point reports exactly one.
+  const auto one = musical_tick(1000, 750, 1., 0.75);
+  const auto r = one.get_quantification_dates(16.);
+  REQUIRE(r.size() == 1);
+  REQUIRE(r[0].date.impl == 1000);
+
+  // A tick with no musical duration at all still falls back to prev_date, which
+  // is what nodes driven with the musical fields left at zero rely on.
+  const auto flat = musical_tick(1000, 900, 0., 0.);
+  const auto fr = flat.get_quantification_dates(16.);
+  REQUIRE(fr.size() == 1);
+  REQUIRE(fr[0].date.impl == 1000);
+}
+
+TEST_CASE("test_quantification_dates_direction_mismatch",
+          "test_quantification_dates_direction_mismatch")
+{
+  // An interval whose own speed is negative under a parent that is already
+  // rewinding ticks forward while inheriting the parent's decreasing musical
+  // positions. Walking that with the clamps of the other direction discards
+  // every point.
+  auto fwd_tick_bwd_music = musical_tick(0, 1000, 1., 0.);
+  fwd_tick_bwd_music.speed = 1.;
+  const auto r = fwd_tick_bwd_music.get_quantification_dates(16.);
+  REQUIRE(r.size() == 1);
+  REQUIRE(r[0].date.impl == 0);
+
+  // And the mirror: a backward tick carrying increasing musical positions.
+  auto bwd_tick_fwd_music = musical_tick(1000, 0, 0., 1.);
+  bwd_tick_fwd_music.speed = -1.;
+  const auto r2 = bwd_tick_fwd_music.get_quantification_dates(16.);
+  REQUIRE(r2.size() == 1);
+  REQUIRE(r2[0].date.impl == 1000);
+
+  // metronome() must not interpolate with a negative musical duration either.
+  bool fired = false;
+  fwd_tick_bwd_music.musical_start_last_bar = 1.;
+  fwd_tick_bwd_music.musical_end_last_bar = 0.;
+  fwd_tick_bwd_music.metronome(
+      unit_ratio, [&](int64_t) { fired = true; }, [&](int64_t) { fired = true; });
+  REQUIRE(!fired);
+}
+
+TEST_CASE("test_quantification_date_backward_is_none",
+          "test_quantification_date_backward_is_none")
+{
+  // Used for quantized triggering: interval start / stop, looper record.
+  const auto bwd = musical_tick(1000, 0, 1., 0.);
+  REQUIRE(!bwd.get_quantification_date(16.).has_value());
+  REQUIRE(!bwd.get_quantification_date(1.).has_value());
+  REQUIRE(!bwd.get_physical_quantification_date(16., unit_ratio).has_value());
+
+  const auto fwd = musical_tick(0, 900, 0.1, 0.9);
+  REQUIRE(fwd.get_quantification_date(16.).has_value());
+}
+
+namespace
+{
+struct metro_result
+{
+  std::optional<int64_t> hi;
+  std::optional<int64_t> lo;
+};
+
+metro_result run_metronome(const ossia::token_request& t)
+{
+  metro_result r;
+  t.metronome(
+      unit_ratio, [&](int64_t s) { r.hi = s; }, [&](int64_t s) { r.lo = s; });
+  return r;
+}
+}
+
+TEST_CASE("test_metronome_both_directions", "test_metronome_both_directions")
+{
+  // A bar line halfway through the tick, crossed forwards then backwards: the
+  // click lands on the same sample either way, because rewinding plays that
+  // half of the buffer in reverse.
+  {
+    auto fwd = musical_tick(0, 1000, 3.5, 4.5);
+    fwd.musical_start_last_bar = 0.;
+    fwd.musical_end_last_bar = 4.;
+    const auto r = run_metronome(fwd);
+    REQUIRE(r.hi.has_value());
+    REQUIRE(*r.hi == 500);
+    REQUIRE(!r.lo.has_value());
+  }
+  {
+    auto bwd = musical_tick(1000, 0, 4.5, 3.5);
+    bwd.musical_start_last_bar = 4.;
+    bwd.musical_end_last_bar = 0.;
+    const auto r = run_metronome(bwd);
+    REQUIRE(r.hi.has_value());
+    REQUIRE(*r.hi == 500);
+    REQUIRE(!r.lo.has_value());
+  }
+
+  // Same for a quarter inside the bar.
+  {
+    const auto fwd = musical_tick(0, 1000, 0.5, 1.5);
+    const auto r = run_metronome(fwd);
+    REQUIRE(r.lo.has_value());
+    REQUIRE(*r.lo == 500);
+    REQUIRE(!r.hi.has_value());
+  }
+  {
+    const auto bwd = musical_tick(1000, 0, 1.5, 0.5);
+    const auto r = run_metronome(bwd);
+    REQUIRE(r.lo.has_value());
+    REQUIRE(*r.lo == 500);
+    REQUIRE(!r.hi.has_value());
+  }
+
+  // A tick that crosses nothing is silent, both ways.
+  for(const auto& t :
+      {musical_tick(0, 1000, 0.1, 0.4), musical_tick(1000, 0, 0.4, 0.1)})
+  {
+    const auto r = run_metronome(t);
+    REQUIRE(!r.hi.has_value());
+    REQUIRE(!r.lo.has_value());
+  }
+}
+
+TEST_CASE("test_metronome_stays_inside_the_tick", "test_metronome_stays_inside_the_tick")
+{
+  // A bar line landing exactly on a tick boundary belongs to the tick that
+  // starts on it, where it is sample 0, not to the one that ends on it, where
+  // it could only be the last sample and so a sample early.
+  {
+    auto ends_on_it = musical_tick(0, 1000, 3.5, 4.0);
+    ends_on_it.musical_start_last_bar = 0.;
+    ends_on_it.musical_end_last_bar = 4.;
+    const auto r = run_metronome(ends_on_it);
+    REQUIRE(!r.hi.has_value());
+
+    auto starts_on_it = musical_tick(1000, 2000, 4.0, 4.5);
+    starts_on_it.musical_start_last_bar = 4.;
+    starts_on_it.musical_end_last_bar = 4.;
+    const auto r2 = run_metronome(starts_on_it);
+    REQUIRE(r2.hi.has_value());
+    REQUIRE(*r2.hi == 0);
+  }
+
+  // Every crossing, whatever the geometry, reports a sample inside the tick.
+  for(double start : {0.0, 0.3, 1.0, 3.5, 3.99})
+  {
+    for(double span : {0.25, 1., 2., 4.5})
+    {
+      for(bool rewind : {false, true})
+      {
+        auto t = rewind ? musical_tick(1000, 0, start + span, start)
+                        : musical_tick(0, 1000, start, start + span);
+        t.musical_start_last_bar = rewind ? 4. : 0.;
+        t.musical_end_last_bar = rewind ? 0. : 4.;
+        CAPTURE(start, span, rewind);
+
+        const auto res = run_metronome(t);
+        for(auto s : {res.hi, res.lo})
+        {
+          if(s)
+          {
+            REQUIRE(*s >= 0);
+            REQUIRE(*s < 1000);
+          }
+        }
+      }
+    }
+  }
+}
+
+TEST_CASE("test_metronome_direction_mismatch", "test_metronome_direction_mismatch")
+{
+  // Musical positions that disagree with the tick's direction: nothing to
+  // interpolate, and interpolating anyway would land outside the buffer.
+  auto t = musical_tick(0, 1000, 4.5, 3.5);
+  t.speed = 1.;
+  t.musical_start_last_bar = 4.;
+  t.musical_end_last_bar = 0.;
+  const auto r = run_metronome(t);
+  REQUIRE(!r.hi.has_value());
+  REQUIRE(!r.lo.has_value());
+}
+
+TEST_CASE("test_bar_change_backward", "test_bar_change_backward")
+{
+  // A bar change is a bar change in both directions.
+  auto b = musical_tick(1000, 0, 4., 2.);
+  b.musical_start_last_bar = 4.;
+  b.musical_end_last_bar = 2.;
+  b.signature = {4, 4};
+  REQUIRE(b.unexpected_bar_change());
+
+  b.musical_start_last_bar = 4.;
+  b.musical_end_last_bar = 0.;
+  REQUIRE(!b.unexpected_bar_change());
+}
+
+TEST_CASE("test_sound_raw_mode_ignores_tempo", "test_sound_raw_mode_ignores_tempo")
+{
+  // Stretch mode None plays the file at its own rate: nothing derived from the
+  // tick may depend on the live tempo.
+  ossia::execution_state e;
+  e.bufferSize = 256;
+  e.modelToSamplesRatio = unit_ratio;
+  e.samplesToModelRatio = unit_ratio;
+  ossia::exec_state_facade st{&e};
+
+  ossia::sound_processing_info info;
+  info.set_native_tempo(120.);
+  info.set_loop_info(ossia::time_value{4000}, ossia::time_value{700}, true);
+
+  auto at_tempo = [&](double tempo) {
+    auto t = tick(0, 256, 0, 1.);
+    t.tempo = tempo;
+    const double stretch = info.update_stretch(t, st);
+    return std::tuple{
+        stretch, info.m_loop_duration_samples, info.m_start_offset_samples};
+  };
+
+  const auto [s120, l120, o120] = at_tempo(120.);
+  REQUIRE(s120 == 1.);
+  REQUIRE(l120 == 4000);
+  REQUIRE(o120 == 700);
+
+  for(double tempo : {60., 90., 140., 200., 240.})
+  {
+    CAPTURE(tempo);
+    const auto [s, l, o] = at_tempo(tempo);
+    REQUIRE(s == 1.);
+    REQUIRE(l == l120);
+    REQUIRE(o == o120);
+  }
+}
+
+TEST_CASE("test_timings_direction_symmetric", "test_timings_direction_symmetric")
+{
+  ossia::execution_state e;
+  e.bufferSize = 256;
+  e.modelToSamplesRatio = unit_ratio;
+  e.samplesToModelRatio = unit_ratio;
+  ossia::exec_state_facade st{&e};
+
+  struct
+  {
+    int64_t offset;
+    int64_t dur;
+  } cases[] = {{0, 256}, {0, 128}, {128, 128}, {64, 64}, {200, 56}};
+
+  for(auto& c : cases)
+  {
+    CAPTURE(c.offset, c.dur);
+    const auto f = st.timings(tick(0, c.dur, c.offset, 1.));
+    const auto b = st.timings(tick(c.dur, 0, c.offset, -1.));
+
+    REQUIRE(f.start_sample == c.offset);
+    REQUIRE(f.length == c.dur);
+    REQUIRE(b.start_sample == f.start_sample);
+    REQUIRE(b.length == f.length);
+    REQUIRE(b.start_sample + b.length <= e.bufferSize);
+  }
+
+  // Speed too close to zero: nothing to do, and no out-of-range values.
+  {
+    const auto z = st.timings(tick(0, 0, 0, 0.));
+    REQUIRE(z.start_sample == 0);
+    REQUIRE(z.length == 0);
+  }
+}
+
+TEST_CASE("metronome_reports_a_bar_line_from_a_signature_change", "metronome_reports_a_bar_line_from_a_signature_change")
+{
+  // A bar line created by a signature change mid-tick: the bar restarts at
+  // quarter 6 although the previous bar started at 4 (4/4). The old code used
+  // musical_end_last_bar and fired the downbeat; the walk-from-start-bar code
+  // only knows bars at start_last_bar + k*quarters_in_bar.
+  {
+    auto t = musical_tick(5500, 6500, 5.5, 6.5);
+    t.musical_start_last_signature = 0.;
+    t.musical_start_last_bar = 4.;
+    t.musical_end_last_bar = 6.;
+    const auto r = run_metronome(t);
+    CAPTURE(r.hi.has_value(), r.lo.has_value());
+    CHECK(r.hi.has_value()); // downbeat at quarter 6, sample 500
+  }
+  // Same, with the change on a half-quarter so no stale grid point coincides.
+  {
+    auto t = musical_tick(6200, 6800, 6.2, 6.8);
+    t.musical_start_last_signature = 0.;
+    t.musical_start_last_bar = 4.;
+    t.musical_end_last_bar = 6.5;
+    const auto r = run_metronome(t);
+    CAPTURE(r.hi.has_value(), r.lo.has_value());
+    CHECK((r.hi.has_value() || r.lo.has_value())); // downbeat at 6.5 dropped entirely?
+  }
+}
diff --git a/tests/Dataflow/SoundSyncTest.cpp b/tests/Dataflow/SoundSyncTest.cpp
new file mode 100644
index 00000000000..99a522f6f26
--- /dev/null
+++ b/tests/Dataflow/SoundSyncTest.cpp
@@ -0,0 +1,925 @@
+// Sync harness for the sound nodes: measures, in samples, how far each
+// timestretch mode strays from the ideal output grid, for files whose native
+// tempo differs from the timeline tempo, both when started from the beginning
+// and when dropped in mid-playback.
+//
+// The signal is a click track: one full-scale sample every 60/file_tempo
+// seconds, silence elsewhere. Sync error then *is* impulse position error:
+// for each output we locate every click and compare it against the position
+// it must occupy, so two files agreeing with each other while both drifting
+// still fail, which a pairwise cross-correlation would miss.
+//
+// The token stream mirrors what score actually produces (buffer_tick ->
+// scenario -> time_interval::tick_offset): for a transport tempo T and
+// transport speed s,
+//   - token.tempo  = s * T                  (time_interval::m_current_tempo)
+//   - token.speed  = s * T / root_tempo     (time_interval::m_globalSpeed)
+//   - the model date advances by floor(buffer_flicks * speed + residue) with
+//     the residue carried, exactly like time_interval::take_step().
+// The earlier harness in SoundTest.cpp advanced the model date at unit rate
+// with token.speed = 1, which only coincides with production when T == 120;
+// every conclusion drawn at other tempi through it was measured against a
+// token stream the engine never emits.
+//
+// Under this convention the file position of a stretched sound is a pure
+// function of the model date: consumption is tempo(t)/file_tempo file samples
+// per physical sample while the model advances at tempo(t)/root_tempo, so
+// d(file)/d(model) = root_tempo / file_tempo whatever the tempo curve or
+// speed do. The drop-in tests pin exactly that invariant.
+//
+// The file is deliberately self-contained over the public-ish node API so it
+// can be cherry-picked onto older revisions: the carried sample span fields
+// of token_request are detected at compile time and skipped when absent.
+
+#define _USE_MATH_DEFINES
+#include <ossia/dataflow/execution_state.hpp>
+#include <ossia/dataflow/nodes/sound_ref.hpp>
+
+#include "include_catch.hpp"
+
+#include <ossia/detail/thread.hpp>
+
+#include <algorithm>
+#include <cmath>
+#include <cstdio>
+#include <memory>
+#include <vector>
+
+namespace
+{
+using namespace ossia;
+
+constexpr int64_t fps = ossia::flicks_per_second<int64_t>;
+
+template <typename T>
+concept has_sample_span = requires(T t) {
+  t.start_sample;
+  t.length_sample;
+};
+
+// Reproduces the token stream time_interval emits when driven by buffer_tick
+// with a transport tempo and speed: floor-with-residue model advancement, the
+// global speed in token.speed, the tempo scaled by the speed in token.tempo.
+struct production_ticker
+{
+  int sampleRate{};
+  int bufferSize{};
+  double transport_tempo{};
+  double speed{};
+
+  int64_t model_date = 0;
+  double residue = 0.;
+
+  [[nodiscard]] double global_speed() const noexcept
+  {
+    return speed * transport_tempo / ossia::root_tempo;
+  }
+
+  ossia::token_request next() noexcept
+  {
+    const int64_t buf_flicks = int64_t(bufferSize) * (fps / sampleRate);
+    const double want = double(buf_flicks) * global_speed() + residue;
+    const double step = std::floor(want);
+    residue = want - step;
+    const int64_t adv = int64_t(step);
+
+    ossia::token_request tk{
+        ossia::time_value{model_date},
+        ossia::time_value{model_date + adv},
+        ossia::time_value{fps * int64_t(3600)},
+        ossia::time_value{0},
+        global_speed(),
+        {4, 4},
+        speed * transport_tempo};
+    // Dependent context so the branch is genuinely discarded on revisions
+    // whose token_request has no carried sample span.
+    [&]<typename TK>(TK& t) {
+      if constexpr(has_sample_span<TK>)
+      {
+        t.start_sample = 0;
+        t.length_sample = int32_t(bufferSize);
+      }
+    }(tk);
+    model_date += adv;
+    return tk;
+  }
+};
+
+// One sample of 1.0 every 60/tempo seconds. Click k sits at round(k*period),
+// so its exact file position is known and the expected output position can be
+// derived from it rather than from the idealized (fractional) grid.
+ossia::audio_array make_click_track(double file_tempo, int sampleRate, int64_t frames)
+{
+  ossia::audio_array d;
+  d.resize(1);
+  d[0].assign(frames, 0.f);
+  const double period = 60.0 / file_tempo * sampleRate;
+  for(int64_t k = 0;; k++)
+  {
+    const auto pos = int64_t(std::llround(double(k) * period));
+    if(pos >= frames)
+      break;
+    d[0][pos] = 1.f;
+  }
+  return d;
+}
+
+std::unique_ptr<ossia::nodes::sound_ref> make_click_node(
+    const ossia::audio_array& data, ossia::audio_stretch_mode mode, int sampleRate,
+    double file_tempo)
+{
+  auto n = std::make_unique<ossia::nodes::sound_ref>();
+  n->set_sound(data);
+  // The testing set_sound() forces stretch mode None and a 44100 data rate;
+  // override both so the click positions mean what the harness thinks.
+  n->m_sampler.m_dataSampleRate = sampleRate;
+  n->m_resampler.reset(0, mode, 1, sampleRate);
+  n->set_native_tempo(file_tempo);
+  return n;
+}
+
+// Runs the node over tokens [first_tick, first_tick + n_ticks[ of the shared
+// timeline and returns its output, one bufferSize block per tick. The port is
+// cleared before every tick so unwritten samples read as silence instead of
+// stale data.
+std::vector<float> run_node(
+    ossia::nodes::sound_ref& n, ossia::execution_state& e,
+    const std::vector<ossia::token_request>& tokens, std::size_t first_tick,
+    std::size_t n_ticks, int bufferSize)
+{
+  std::vector<float> out;
+  out.reserve(n_ticks * bufferSize);
+  for(std::size_t k = first_tick; k < first_tick + n_ticks; k++)
+  {
+    n.audio_out.data.get().clear();
+    n.run(tokens[k], ossia::exec_state_facade{&e});
+    if(n.audio_out.data.channels() >= 1)
+    {
+      auto& ch = n.audio_out.data.channel(0);
+      for(int i = 0; i < bufferSize; i++)
+        out.push_back(i < int(ch.size()) ? float(ch[i]) : 0.f);
+    }
+    else
+    {
+      out.insert(out.end(), bufferSize, 0.f);
+    }
+  }
+  return out;
+}
+
+struct click_stats
+{
+  int found{};
+  int missing{};
+  double median_err{};  // signed samples, found - expected
+  double max_abs_err{};
+  double first_err{};
+  double last_err{};
+  double drift_per_min{}; // least-squares slope of error vs position, samples/min
+};
+
+// For each expected click position, search +-radius for the peak; a window
+// whose maximum stays below the threshold counts as a missing click. This is
+// robust to the smearing of a stretcher as long as the peak stays the peak.
+click_stats measure_clicks(
+    const std::vector<float>& out, const std::vector<double>& expected, double radius,
+    int sampleRate, float threshold = 0.25f)
+{
+  click_stats st{};
+  std::vector<double> errs;
+  std::vector<double> poss;
+  for(double pos : expected)
+  {
+    const auto lo = int64_t(std::floor(pos - radius));
+    const auto hi = int64_t(std::ceil(pos + radius));
+    if(lo < 0 || hi >= int64_t(out.size()))
+      continue;
+    int64_t best = lo;
+    float best_v = 0.f;
+    for(int64_t i = lo; i <= hi; i++)
+    {
+      const float v = std::abs(out[i]);
+      if(v > best_v)
+      {
+        best_v = v;
+        best = i;
+      }
+    }
+    if(best_v < threshold)
+    {
+      st.missing++;
+      continue;
+    }
+    errs.push_back(double(best) - pos);
+    poss.push_back(pos);
+  }
+  st.found = int(errs.size());
+  if(errs.empty())
+    return st;
+
+  st.first_err = errs.front();
+  st.last_err = errs.back();
+  for(double e : errs)
+    st.max_abs_err = std::max(st.max_abs_err, std::abs(e));
+
+  auto sorted = errs;
+  std::sort(sorted.begin(), sorted.end());
+  st.median_err = sorted[sorted.size() / 2];
+
+  // Least-squares slope of err against position, in samples per minute.
+  if(errs.size() >= 2)
+  {
+    double mx = 0, my = 0;
+    for(std::size_t i = 0; i < errs.size(); i++)
+    {
+      mx += poss[i];
+      my += errs[i];
+    }
+    mx /= errs.size();
+    my /= errs.size();
+    double num = 0, den = 0;
+    for(std::size_t i = 0; i < errs.size(); i++)
+    {
+      num += (poss[i] - mx) * (errs[i] - my);
+      den += (poss[i] - mx) * (poss[i] - mx);
+    }
+    if(den > 0)
+      st.drift_per_min = num / den * 60. * sampleRate;
+  }
+  return st;
+}
+
+const char* mode_name(ossia::audio_stretch_mode m)
+{
+  switch(m)
+  {
+    case ossia::audio_stretch_mode::None:
+      return "raw     ";
+    case ossia::audio_stretch_mode::Repitch:
+      return "repitch ";
+    case ossia::audio_stretch_mode::RubberBandStandard:
+      return "rubber  ";
+    case ossia::audio_stretch_mode::RubberBandStandardHQ:
+      return "rubberHQ";
+    default:
+      return "?       ";
+  }
+}
+
+struct sync_case
+{
+  ossia::audio_stretch_mode mode{};
+  double file_tempo{};
+  double transport_tempo{};
+  double speed{1.0};
+  int bufferSize{512};
+  int sampleRate{44100};
+};
+
+struct sync_result
+{
+  sync_case c;
+  click_stats started; // node playing from 0, measured after the drop point
+  click_stats dropped; // node dropped at the drop point
+  int64_t seek_actual{};
+  int64_t seek_expected{};
+};
+
+// Runs one scenario: node A plays from 0; node B is dropped mid-playback the
+// way add_time_process() drops it (transport(m_date, current_transport_info())).
+// Both outputs are measured against the absolute expected click positions.
+sync_result run_sync_case(const sync_case& c)
+{
+  const int sampleRate = c.sampleRate;
+  const int N = c.bufferSize;
+
+  const double phys_seconds = 12.0;
+  const std::size_t n_ticks = std::size_t(phys_seconds * sampleRate) / N;
+  const std::size_t drop_tick = n_ticks / 3;
+  const int64_t P0 = int64_t(drop_tick) * N; // physical sample of the drop
+
+  // File consumption rate in file samples per physical output sample.
+  const bool stretching = c.mode != ossia::audio_stretch_mode::None;
+  const double consumption
+      = stretching ? c.speed * c.transport_tempo / c.file_tempo : 1.0;
+
+  // Enough file for the whole run at the fastest consumption, plus slack.
+  const auto file_frames
+      = int64_t(phys_seconds * sampleRate * consumption) + 8 * 65536;
+  const auto data = make_click_track(c.file_tempo, sampleRate, file_frames);
+
+  ossia::execution_state e;
+  e.bufferSize = N;
+  e.sampleRate = sampleRate;
+  e.modelToSamplesRatio = double(sampleRate) / double(fps);
+  e.samplesToModelRatio = double(fps) / double(sampleRate);
+
+  production_ticker ticker{sampleRate, N, c.transport_tempo, c.speed};
+  std::vector<ossia::token_request> tokens;
+  tokens.reserve(n_ticks);
+  for(std::size_t k = 0; k < n_ticks; k++)
+    tokens.push_back(ticker.next());
+
+  auto A = make_click_node(data, c.mode, sampleRate, c.file_tempo);
+  const auto outA = run_node(*A, e, tokens, 0, n_ticks, N);
+
+  auto B = make_click_node(data, c.mode, sampleRate, c.file_tempo);
+  ossia::tick_transport_info tinfo{};
+  tinfo.date = tokens[drop_tick].prev_date;
+  tinfo.current_tempo = c.speed * c.transport_tempo;
+  B->transport(tokens[drop_tick].prev_date, tinfo);
+
+  sync_result r{};
+  r.c = c;
+  r.seek_actual = B->m_resampler.next_sample_to_read();
+  r.seek_expected = int64_t(std::llround(double(P0) * consumption));
+
+  const auto outB = run_node(*B, e, tokens, drop_tick, n_ticks - drop_tick, N);
+
+  // Expected positions: click k sits at file position F_k; it must come out
+  // at physical F_k / consumption. For B the origin is the drop point.
+  const double period = 60.0 / c.file_tempo * sampleRate;
+  const double out_spacing = period / consumption;
+  const double radius = std::min(0.45 * out_spacing, 4096.);
+
+  std::vector<double> expectA, expectB;
+  for(int64_t k = 0;; k++)
+  {
+    const double F = double(int64_t(std::llround(double(k) * period)));
+    const double P = F / consumption;
+    if(P >= double(n_ticks * N))
+      break;
+    // Skip the transient right at the start of each stream: the first click
+    // of a freshly primed stretcher is starting-latency, not sync.
+    if(P > 2.5 * out_spacing)
+      expectA.push_back(P);
+    if(P - double(P0) > 2.5 * out_spacing)
+      expectB.push_back(P - double(P0));
+  }
+
+  // Measure A over the same span B exists in, so the two stats face the same
+  // part of the timeline.
+  std::vector<double> expectA_tail;
+  for(double p : expectA)
+    if(p > double(P0))
+      expectA_tail.push_back(p);
+
+  r.started = measure_clicks(outA, expectA_tail, radius, sampleRate);
+  r.dropped = measure_clicks(outB, expectB, radius, sampleRate);
+  return r;
+}
+
+void print_result_header()
+{
+  std::fprintf(
+      stderr,
+      "\n%-9s %5s %5s %6s %5s | %7s %8s %9s %4s | %7s %8s %9s %4s | %10s\n",
+      "mode", "fTmp", "tTmp", "speed", "buf", "st.med", "st.max", "st.drift",
+      "miss", "dr.med", "dr.max", "dr.drift", "miss", "seek err");
+}
+
+void print_result(const sync_result& r)
+{
+  std::fprintf(
+      stderr,
+      "%-9s %5.0f %5.0f %6.3f %5d | %7.1f %8.1f %9.3f %4d | %7.1f %8.1f %9.3f %4d | %10lld\n",
+      mode_name(r.c.mode), r.c.file_tempo, r.c.transport_tempo, r.c.speed,
+      r.c.bufferSize, r.started.median_err, r.started.max_abs_err,
+      r.started.drift_per_min, r.started.missing, r.dropped.median_err,
+      r.dropped.max_abs_err, r.dropped.drift_per_min, r.dropped.missing,
+      (long long)(r.seek_actual - r.seek_expected));
+}
+}
+
+#if defined(OSSIA_ENABLE_RUBBERBAND) && defined(OSSIA_ENABLE_LIBSAMPLERATE)
+
+TEST_CASE("sound_sync_sweep", "[sound][sync]")
+{
+  ossia::set_thread_pinned(ossia::thread_type::Ui, 0);
+
+  // Experimentation knob: OSSIA_SOUND_SYNC_PRIME=<0..4> selects the
+  // rubberband priming strategy for the whole sweep. Unset = production
+  // default.
+  if(const char* p = std::getenv("OSSIA_SOUND_SYNC_PRIME"))
+  {
+    ossia::rubberband_stretcher::s_prime_strategy
+        = ossia::rubberband_stretcher::prime_strategy(std::atoi(p));
+    std::fprintf(stderr, "prime strategy override: %s\n", p);
+  }
+
+  using m = ossia::audio_stretch_mode;
+  std::vector<sync_case> cases;
+
+  // Baseline: buffer 512, speed 1.
+  for(double fT : {90., 120., 128., 140.})
+    for(double tT : {120., 140.})
+      for(auto mode : {m::None, m::Repitch, m::RubberBandStandard})
+        cases.push_back({mode, fT, tT, 1.0, 512});
+
+  // Small buffers.
+  for(double fT : {90., 128.})
+    for(auto mode : {m::None, m::Repitch, m::RubberBandStandard})
+      cases.push_back({mode, fT, 140., 1.0, 64});
+
+  // Fractional transport speed: buffer_frames * speed is not a whole number
+  // of flicks, the residue-carry path is active every tick.
+  for(double fT : {90., 128.})
+    for(double tT : {120., 140.})
+      for(auto mode : {m::None, m::Repitch, m::RubberBandStandard})
+        cases.push_back({mode, fT, tT, 1.234, 512});
+  for(auto mode : {m::None, m::Repitch, m::RubberBandStandard})
+    cases.push_back({mode, 128., 140., 1.234, 64});
+
+  print_result_header();
+  for(const auto& c : cases)
+  {
+    const auto r = run_sync_case(c);
+    print_result(r);
+
+    INFO(
+        mode_name(r.c.mode) << " fT=" << r.c.file_tempo << " tT="
+                            << r.c.transport_tempo << " s=" << r.c.speed
+                            << " buf=" << r.c.bufferSize);
+
+    const bool stretching = c.mode != m::None;
+    if(stretching)
+    {
+      // Files started together must sit on the grid; files dropped in must
+      // land on the same grid. Repitch is sample-accurate; the R2 rubberband
+      // engine places transients with a bounded jitter of up to ~2 hops
+      // around the correct position, so its tolerances are its noise floor,
+      // not an accepted drift. Drift itself is asserted in the long-run test
+      // below: over these 8-second windows a least-squares slope through
+      // R2's jitter measures the jitter, not the tracking.
+      const bool rb = c.mode == m::RubberBandStandard;
+      const double med_tol = rb ? 48. : 2.;
+      const double max_tol = rb ? 160. : 4.;
+
+      // How many clicks the detector is allowed not to find at all. The
+      // deterministic resamplers must produce every one. RubberBand smears
+      // transients by an amount that depends on the library version and its
+      // build options - CI's is not the one this was measured against - so a
+      // few of its clicks can fall under the detector's threshold without
+      // anything being out of sync. What sync we do have is asserted by the
+      // errors below, over the clicks that were found.
+      const int missing_tol = rb ? 4 : 0;
+      CHECK(r.started.missing <= missing_tol);
+      CHECK(std::abs(r.started.median_err) < med_tol);
+      CHECK(r.started.max_abs_err < max_tol);
+
+      CHECK(r.dropped.missing <= missing_tol);
+      CHECK(std::abs(r.dropped.median_err) < med_tol);
+      CHECK(r.dropped.max_abs_err < max_tol);
+
+      // And the dropped file must agree with the running one.
+      const double agree_tol = c.mode == m::RubberBandStandard ? 32. : 2.;
+      CHECK(std::abs(r.dropped.median_err - r.started.median_err) < agree_tol);
+    }
+
+    // A dropped file must continue from the file position the running copy
+    // has reached - in every mode, including raw, where the file position is
+    // simply the physical time elapsed.
+    CHECK(std::llabs(r.seek_actual - r.seek_expected) <= 1);
+  }
+}
+
+// Files started together and left running for a whole minute: quantifies
+// long-run drift much more sensitively than the sweep, for the two stretchers
+// at an irrational tempo ratio.
+TEST_CASE("sound_sync_long_run", "[sound][sync]")
+{
+  ossia::set_thread_pinned(ossia::thread_type::Ui, 0);
+
+  constexpr int sampleRate = 44100;
+  constexpr int N = 512;
+  const double phys_seconds = 60.0;
+  const std::size_t n_ticks = std::size_t(phys_seconds * sampleRate) / N;
+
+  struct
+  {
+    double fT, tT;
+  } ratios[] = {{90., 140.}, {128., 140.}, {140., 120.}};
+
+  for(const auto& [fT, tT] : ratios)
+  {
+    const double consumption = tT / fT;
+
+    const auto file_frames
+        = int64_t(phys_seconds * sampleRate * consumption) + 8 * 65536;
+    const auto data = make_click_track(fT, sampleRate, file_frames);
+
+    ossia::execution_state e;
+    e.bufferSize = N;
+    e.sampleRate = sampleRate;
+    e.modelToSamplesRatio = double(sampleRate) / double(fps);
+    e.samplesToModelRatio = double(fps) / double(sampleRate);
+
+    production_ticker ticker{sampleRate, N, tT, 1.0};
+    std::vector<ossia::token_request> tokens;
+    for(std::size_t k = 0; k < n_ticks; k++)
+      tokens.push_back(ticker.next());
+
+    const double period = 60.0 / fT * sampleRate;
+    const double out_spacing = period / consumption;
+
+    for(auto mode :
+        {ossia::audio_stretch_mode::Repitch,
+         ossia::audio_stretch_mode::RubberBandStandard})
+    {
+      auto n = make_click_node(data, mode, sampleRate, fT);
+      const auto out = run_node(*n, e, tokens, 0, n_ticks, N);
+
+      std::vector<double> expect;
+      for(int64_t k = 0;; k++)
+      {
+        const double F = double(int64_t(std::llround(double(k) * period)));
+        const double P = F / consumption;
+        if(P >= double(n_ticks * N))
+          break;
+        if(P > 2.5 * out_spacing)
+          expect.push_back(P);
+      }
+
+      const auto st = measure_clicks(
+          out, expect, std::min(0.45 * out_spacing, 4096.), sampleRate);
+      std::fprintf(
+          stderr,
+          "[long run %s %3.0f->%3.0f] clicks=%d missing=%d median=%.1f max=%.1f "
+          "first=%.1f last=%.1f drift=%.3f samples/min\n",
+          mode_name(mode), fT, tT, st.found, st.missing, st.median_err,
+          st.max_abs_err, st.first_err, st.last_err, st.drift_per_min);
+
+      INFO(mode_name(mode) << " " << fT << "->" << tT);
+      const bool rb = mode == ossia::audio_stretch_mode::RubberBandStandard;
+      CHECK(st.missing == 0);
+      // Real long-run drift: repitch tracks the ratio exactly; R2's slope
+      // estimate carries its transient jitter divided by the window, hence
+      // the wider bound.
+      CHECK(std::abs(st.drift_per_min) < (rb ? 8.0 : 1.0));
+      CHECK(std::abs(st.median_err) < (rb ? 48. : 2.));
+    }
+  }
+}
+
+// The invariant the drop-in seek must respect: with production tokens the
+// file position of a stretched sound is model_samples * root_tempo/file_tempo
+// no matter the transport tempo or speed, because both the model clock and
+// the consumption scale with the live tempo. A dropped file that seeks
+// anywhere else starts flamming against the copies already playing.
+TEST_CASE("sound_sync_drop_seek_invariant", "[sound][sync]")
+{
+  ossia::set_thread_pinned(ossia::thread_type::Ui, 0);
+
+  using m = ossia::audio_stretch_mode;
+  struct
+  {
+    m mode;
+    double fT, tT, speed;
+  } cases[] = {
+      {m::Repitch, 100., 120., 1.0},  // the historical baseline: must not move
+      {m::Repitch, 90., 140., 1.0},
+      {m::Repitch, 128., 140., 1.234},
+      {m::RubberBandStandard, 90., 140., 1.0},
+      {m::RubberBandStandard, 128., 140., 1.234},
+      {m::None, 128., 140., 1.0},
+  };
+
+  constexpr int sampleRate = 44100;
+  constexpr int N = 512;
+  for(const auto& c : cases)
+  {
+    const bool stretching = c.mode != m::None;
+    const double consumption = stretching ? c.speed * c.tT / c.fT : 1.0;
+
+    // 4 seconds in, like the sweep's drop point.
+    production_ticker ticker{sampleRate, N, c.tT, c.speed};
+    const std::size_t drop_tick = std::size_t(4.0 * sampleRate) / N;
+    ossia::token_request last{};
+    for(std::size_t k = 0; k < drop_tick; k++)
+      last = ticker.next();
+    const int64_t P0 = int64_t(drop_tick) * N;
+
+    ossia::audio_array data;
+    data.resize(1);
+    data[0].assign(1024, 0.f);
+    auto node = make_click_node(data, c.mode, sampleRate, c.fT);
+
+    ossia::tick_transport_info tinfo{};
+    tinfo.date = last.date;
+    tinfo.current_tempo = c.speed * c.tT;
+    node->transport(last.date, tinfo);
+
+    const auto seek = node->m_resampler.next_sample_to_read();
+    const auto want = int64_t(std::llround(double(P0) * consumption));
+    INFO(
+        mode_name(c.mode) << " fT=" << c.fT << " tT=" << c.tT << " s=" << c.speed
+                          << " seek=" << seek << " want=" << want);
+    CHECK(std::llabs(seek - want) <= 1);
+  }
+}
+
+// Adversarial extension of the sweep: ratios far outside the 0.52..1.17 range
+// the R2 start-delay correction was fitted on, the R3 (HQ) engine which must
+// not receive that correction, and a 48 kHz rate. The stretch-mode tolerances
+// scale with the stretcher's own transient jitter, which grows with the
+// stretch factor; what these cases pin down is that the start trim does not
+// misplace the whole stream (an error of the order of the start delay, i.e.
+// hundreds to thousands of samples).
+TEST_CASE("sound_sync_extreme_ratios", "[sound][sync]")
+{
+  ossia::set_thread_pinned(ossia::thread_type::Ui, 0);
+
+  using m = ossia::audio_stretch_mode;
+  std::vector<sync_case> cases = {
+      // Repitch tracks any ratio exactly.
+      {m::Repitch, 200., 60., 1.0, 512},
+      {m::Repitch, 60., 200., 1.0, 512},
+      // R3 in the moderate range the R2 correction was fitted on: the
+      // correction must not leak into the finer engine.
+      {m::RubberBandStandardHQ, 90., 140., 1.0, 512},
+      {m::RubberBandStandardHQ, 128., 140., 1.0, 512},
+      // 48 kHz: the pad/delay values change with the rate.
+      {m::RubberBandStandard, 90., 140., 1.0, 512, 48000},
+      {m::RubberBandStandard, 128., 140., 1.0, 512, 48000},
+      {m::RubberBandStandardHQ, 128., 140., 1.0, 512, 48000},
+      {m::Repitch, 128., 140., 1.0, 512, 48000},
+  };
+
+  print_result_header();
+  for(const auto& c : cases)
+  {
+    const auto r = run_sync_case(c);
+    print_result(r);
+
+    INFO(
+        mode_name(r.c.mode) << " fT=" << r.c.file_tempo << " tT="
+                            << r.c.transport_tempo << " s=" << r.c.speed
+                            << " rate=" << r.c.sampleRate);
+
+    const bool rb = c.mode == m::RubberBandStandard
+                    || c.mode == m::RubberBandStandardHQ;
+    // A misapplied start trim shows up as a median offset of ~startDelay
+    // (>= 1024 at these rates), far beyond these.
+    const double med_tol = rb ? 64. : 2.;
+    const double max_tol = rb ? 192. : 4.;
+    CHECK(r.started.missing == 0);
+    CHECK(std::abs(r.started.median_err) < med_tol);
+    CHECK(r.started.max_abs_err < max_tol);
+    CHECK(r.dropped.missing == 0);
+    CHECK(std::abs(r.dropped.median_err) < med_tol);
+    CHECK(std::abs(r.dropped.median_err - r.started.median_err) < med_tol);
+    CHECK(std::llabs(r.seek_actual - r.seek_expected) <= 1);
+  }
+}
+
+// The rubberband engines outside the ratio range the R2 start-delay
+// correction was fitted on (0.52..1.17). Measured today at 44.1 kHz:
+//   R2 at time ratio 3.33 (fT 200 -> tT 60): whole stream ~+1880 samples
+//     late - the 0.375*pad*(1-ratio) term goes far negative and is clamped
+//     to zero, so nothing is trimmed while the true start delay grew.
+//   R3 at 3.33: ~-570 samples early.
+//   R2/R3 at ratio 0.3 (fT 60 -> tT 200): ~15-20 of ~180 clicks missing and
+//     medians of -130/+90: transients are crushed and misplaced.
+// Kept [!mayfail]: these bounds state what correct behaviour would be, the
+// run records how far the stretchers currently are from it.
+TEST_CASE("sound_sync_extreme_ratio_stretchers", "[sound][sync][!mayfail]")
+{
+  ossia::set_thread_pinned(ossia::thread_type::Ui, 0);
+
+  using m = ossia::audio_stretch_mode;
+  std::vector<sync_case> cases = {
+      {m::RubberBandStandard, 200., 60., 1.0, 512},
+      {m::RubberBandStandardHQ, 200., 60., 1.0, 512},
+      {m::RubberBandStandard, 60., 200., 1.0, 512},
+      {m::RubberBandStandardHQ, 60., 200., 1.0, 512},
+  };
+
+  print_result_header();
+  for(const auto& c : cases)
+  {
+    const auto r = run_sync_case(c);
+    print_result(r);
+
+    INFO(
+        mode_name(r.c.mode) << " fT=" << r.c.file_tempo
+                            << " tT=" << r.c.transport_tempo);
+    const double stretch = c.file_tempo / c.transport_tempo;
+    const double med_tol = 64. * std::max(1.0, stretch);
+    const double max_tol = 192. * std::max(1.0, stretch);
+    CHECK(r.started.missing == 0);
+    CHECK(std::abs(r.started.median_err) < med_tol);
+    CHECK(r.started.max_abs_err < max_tol);
+    CHECK(r.dropped.missing == 0);
+    CHECK(std::abs(r.dropped.median_err) < med_tol);
+    CHECK(std::llabs(r.seek_actual - r.seek_expected) <= 1);
+  }
+}
+
+// The drop-in seek claims to be independent of the transport tempo *history*:
+// when stretching, the file position is a pure function of the model date.
+// Play a running copy through a stepped tempo curve (90 BPM for two seconds,
+// then 180), drop a second copy in two seconds after the step, and measure
+// both against the click grid the tempo curve implies. The comparison is on
+// the audible output, not on next_sample_to_read(): a stretcher's input-side
+// position leads its output by its internal buffering, which is not a sync
+// error.
+namespace
+{
+struct curve_run
+{
+  click_stats started;
+  click_stats dropped;
+};
+
+curve_run run_tempo_curve_case(ossia::audio_stretch_mode mode)
+{
+  constexpr int sampleRate = 44100;
+  constexpr int N = 512;
+  const double fT = 128.;
+  const double phys_seconds = 10.0;
+  const std::size_t n_ticks = std::size_t(phys_seconds * sampleRate) / N;
+  const std::size_t drop_tick = std::size_t(4.0 * sampleRate) / N;
+  const int64_t P0 = int64_t(drop_tick) * N;
+
+  const auto tempo_at = [&](std::size_t tick) {
+    return tick < std::size_t(2.0 * sampleRate) / N ? 90. : 180.;
+  };
+
+  const auto file_frames
+      = int64_t(phys_seconds * sampleRate * (180. / fT)) + 8 * 65536;
+  const auto data = make_click_track(fT, sampleRate, file_frames);
+
+  ossia::execution_state e;
+  e.bufferSize = N;
+  e.sampleRate = sampleRate;
+  e.modelToSamplesRatio = double(sampleRate) / double(fps);
+  e.samplesToModelRatio = double(fps) / double(sampleRate);
+
+  // Variable-tempo production tokens: same floor+residue advance, with the
+  // tempo (and so the speed) changing between ticks; and the physical -> file
+  // consumption integral the token stream implies.
+  const bool stretching = mode != ossia::audio_stretch_mode::None;
+  int64_t model_date = 0;
+  double residue = 0.;
+  std::vector<ossia::token_request> tokens;
+  std::vector<double> file_at_tick_start(n_ticks + 1, 0.);
+  for(std::size_t k = 0; k < n_ticks; k++)
+  {
+    const double T = tempo_at(k);
+    const double gspeed = T / ossia::root_tempo;
+    const int64_t buf_flicks = int64_t(N) * (fps / sampleRate);
+    const double want = double(buf_flicks) * gspeed + residue;
+    const double step = std::floor(want);
+    residue = want - step;
+    ossia::token_request tk{
+        ossia::time_value{model_date},
+        ossia::time_value{model_date + int64_t(step)},
+        ossia::time_value{fps * int64_t(3600)},
+        ossia::time_value{0},
+        gspeed,
+        {4, 4},
+        T};
+    tk.start_sample = 0;
+    tk.length_sample = N;
+    tokens.push_back(tk);
+    model_date += int64_t(step);
+
+    const double cons = stretching ? T / fT : 1.0;
+    file_at_tick_start[k + 1] = file_at_tick_start[k] + cons * N;
+  }
+
+  // Physical position at which file sample F comes out, inverting the
+  // per-tick consumption integral.
+  const auto physical_of_file = [&](double F) -> double {
+    for(std::size_t k = 0; k < n_ticks; k++)
+    {
+      if(file_at_tick_start[k + 1] >= F)
+      {
+        const double cons = stretching ? tempo_at(k) / fT : 1.0;
+        return double(k) * N + (F - file_at_tick_start[k]) / cons;
+      }
+    }
+    return -1.;
+  };
+
+  auto A = make_click_node(data, mode, sampleRate, fT);
+  const auto outA = run_node(*A, e, tokens, 0, n_ticks, N);
+
+  auto B = make_click_node(data, mode, sampleRate, fT);
+  ossia::tick_transport_info tinfo{};
+  tinfo.date = tokens[drop_tick].prev_date;
+  tinfo.current_tempo = tempo_at(drop_tick);
+  B->transport(tokens[drop_tick].prev_date, tinfo);
+  const auto outB = run_node(*B, e, tokens, drop_tick, n_ticks - drop_tick, N);
+
+  const double period = 60.0 / fT * sampleRate;
+  const double out_spacing = period / (stretching ? 180. / fT : 1.0);
+  const double radius = std::min(0.45 * out_spacing, 4096.);
+
+  std::vector<double> expectA, expectB;
+  for(int64_t k = 0;; k++)
+  {
+    const double F = double(int64_t(std::llround(double(k) * period)));
+    const double P = physical_of_file(F);
+    if(P < 0.)
+      break;
+    if(P > double(P0) + 2.5 * out_spacing)
+    {
+      expectA.push_back(P);
+      expectB.push_back(P - double(P0));
+    }
+  }
+
+  curve_run r;
+  r.started = measure_clicks(outA, expectA, radius, sampleRate);
+  r.dropped = measure_clicks(outB, expectB, radius, sampleRate);
+  return r;
+}
+}
+
+// What the drop-in commit claims, verified under a tempo curve: the dropped
+// copy seeks to the file position the model date implies and lands on the
+// ideal grid the curve defines. This part holds: repitch is sample-exact,
+// rubberband within its jitter.
+TEST_CASE("sound_sync_drop_tempo_curve_stretch", "[sound][sync]")
+{
+  ossia::set_thread_pinned(ossia::thread_type::Ui, 0);
+  using m = ossia::audio_stretch_mode;
+
+  for(auto mode : {m::Repitch, m::RubberBandStandard})
+  {
+    const auto r = run_tempo_curve_case(mode);
+    std::fprintf(
+        stderr,
+        "[tempo curve %s] started med=%.1f max=%.1f miss=%d | dropped med=%.1f "
+        "max=%.1f miss=%d\n",
+        mode_name(mode), r.started.median_err, r.started.max_abs_err,
+        r.started.missing, r.dropped.median_err, r.dropped.max_abs_err,
+        r.dropped.missing);
+
+    INFO(mode_name(mode));
+    const bool rb = mode == m::RubberBandStandard;
+    const double med_tol = rb ? 48. : 2.;
+    CHECK(r.dropped.missing == 0);
+    CHECK(std::abs(r.dropped.median_err) < med_tol);
+  }
+}
+
+// The counterpart that does not hold: a running copy that lives *through* a
+// tempo step is permanently off the ideal grid afterwards, because the
+// resampler's buffered input crosses the ratio change at the old ratio and
+// the loss is never repaid. Measured with the 90 -> 180 step: repitch stays
+// +158 samples late for the rest of the run, R2 rubberband ~+640. The dropped
+// copy, which never saw the step, sits at 0 - so the two flam by exactly that
+// much despite the seek being correct. Recorded as a measured limitation: the
+// fix would be inside the stretchers' ratio-change handling, not in the seek.
+TEST_CASE(
+    "sound_sync_running_copy_offset_after_tempo_step", "[sound][sync][!mayfail]")
+{
+  ossia::set_thread_pinned(ossia::thread_type::Ui, 0);
+  using m = ossia::audio_stretch_mode;
+
+  for(auto mode : {m::Repitch, m::RubberBandStandard})
+  {
+    const auto r = run_tempo_curve_case(mode);
+    INFO(
+        mode_name(mode) << " started med=" << r.started.median_err
+                        << " dropped med=" << r.dropped.median_err);
+    const bool rb = mode == m::RubberBandStandard;
+    const double med_tol = rb ? 48. : 2.;
+    CHECK(r.started.missing == 0);
+    CHECK(std::abs(r.started.median_err) < med_tol);
+    CHECK(std::abs(r.dropped.median_err - r.started.median_err) < med_tol);
+  }
+}
+
+// Raw playback cannot reconstruct the physical position from the model date
+// once the tempo has changed: the date is the integral of the live tempo while
+// raw consumption is one file sample per physical sample, so dividing the date
+// by the *current* tempo mistakes the whole tempo history for the present.
+// Measured here: after 2 s at 90 BPM and 2 s at 180, the dropped copy seeks
+// 44032 samples (a full second) before the running one - the click matcher
+// reports it as +2688 because 44032 aliases to 2 click periods + 2688. Kept
+// as a measured, documented limitation of the raw drop-in seek rather than a
+// regression: the previous code got the same scenario wrong by a different
+// amount.
+TEST_CASE("sound_sync_drop_tempo_curve_raw", "[sound][sync][!mayfail]")
+{
+  ossia::set_thread_pinned(ossia::thread_type::Ui, 0);
+
+  const auto r = run_tempo_curve_case(ossia::audio_stretch_mode::None);
+  std::fprintf(
+      stderr,
+      "[tempo curve raw] started med=%.1f max=%.1f miss=%d | dropped med=%.1f "
+      "max=%.1f miss=%d\n",
+      r.started.median_err, r.started.max_abs_err, r.started.missing,
+      r.dropped.median_err, r.dropped.max_abs_err, r.dropped.missing);
+
+  CHECK(r.started.missing == 0);
+  CHECK(std::abs(r.started.median_err) < 2.);
+  // The dropped copy: |error| ~= 44100 samples with this curve today.
+  CHECK(r.dropped.missing == 0);
+  CHECK(std::abs(r.dropped.median_err) < 2.);
+}
+
+#endif
diff --git a/tests/Dataflow/SoundTest.cpp b/tests/Dataflow/SoundTest.cpp
index a16dc25d28e..d5be3e7a9ea 100644
--- a/tests/Dataflow/SoundTest.cpp
+++ b/tests/Dataflow/SoundTest.cpp
@@ -52,6 +52,51 @@ TEST_CASE("test_sound_ref", "test_sound_ref")
   REQUIRE(op == expected);
 }
 
+TEST_CASE(
+    "sound_writes_a_span_that_reads_no_new_sample",
+    "sound_writes_a_span_that_reads_no_new_sample")
+{
+  using namespace ossia;
+  nodes::sound_ref snd;
+  ossia::audio_array data;
+  data.resize(1);
+  data[0].assign(128, 1.0f);
+  snd.set_sound(std::move(data));
+
+  execution_state e;
+  e.bufferSize = 64;
+  e.sampleRate = 44100;
+  e.modelToSamplesRatio = 1. / 16000.;
+  e.samplesToModelRatio = 16000.;
+
+  // 1020000 flicks is 63.75 samples into the buffer and the tick ends exactly
+  // on sample 64, so the span is the single sample 63. It consumes a quarter
+  // of a source sample, so the read count floors to zero while the write count
+  // is one: the two are floors of differently phased quantities and a region
+  // starting off a sample boundary hits this on its first tick.
+  ossia::token_request tk;
+  tk.prev_date = 0_tv;
+  tk.date = ossia::time_value{4000};
+  tk.offset = ossia::time_value{1020000};
+  tk.speed = 1.;
+  tk.signature = {4, 4};
+  tk.tempo = 120.;
+
+  const auto si = ossia::snd::sample_info(e.bufferSize, e.modelToSamplesRatio, tk);
+  REQUIRE(si.samples_to_read == 0);
+  REQUIRE(si.samples_to_write == 1);
+
+  snd.run(tk, {&e});
+
+  // Reading nothing new is not a reason to write nothing: skipping the span
+  // leaves a sample of silence at the start of every region that does not
+  // begin on a sample boundary.
+  auto& op = *snd.root_outputs()[0]->target<audio_port>();
+  REQUIRE(op.channels() >= 1);
+  REQUIRE(op.channel(0).size() >= 64);
+  REQUIRE(op.channel(0)[63] != 0.);
+}
+
 #if defined(__GNUC__) || defined(__clang__)
 // http://www-mmsp.ece.mcgill.ca/Documents/AudioFormats/WAVE/WAVE.html
 // https://gist.github.com/Jon-Schneider/8b7c53d27a7a13346a643dac9c19d34f
@@ -399,7 +444,7 @@ TEST_CASE("rubberband_drop_sync_unit_ratio", "[rubberband][sync]")
       best.best_lag_samples,
       1000.0 * best.best_lag_samples / sampleRate);
 
-  rubberband_stretcher::s_prime_strategy = ps::ZeroPadOnly;
+  rubberband_stretcher::s_prime_strategy = ps::BareRecipe;
 
   // CHECK not REQUIRE so failure still prints measurements.
   CHECK(best.best_correlation > 0.9);
@@ -536,7 +581,7 @@ TEST_CASE("rubberband_drop_sync_tempo_shift", "[rubberband][sync]")
 #endif
   run_strategies(seek_mode::stretch_aware);
 
-  rubberband_stretcher::s_prime_strategy = ps::ZeroPadOnly;
+  rubberband_stretcher::s_prime_strategy = ps::BareRecipe;
 }
 
 TEST_CASE("rubberband_drop_then_paste_sync", "[rubberband][sync]")
@@ -652,6 +697,6 @@ TEST_CASE("rubberband_drop_then_paste_sync", "[rubberband][sync]")
     run_case(v.name, audio_stretch_mode::RubberBandStandard);
   }
 
-  rubberband_stretcher::s_prime_strategy = ps::ZeroPadOnly;
+  rubberband_stretcher::s_prime_strategy = ps::BareRecipe;
 }
 #endif
diff --git a/tests/Dataflow/TimingInvariantsTest.cpp b/tests/Dataflow/TimingInvariantsTest.cpp
new file mode 100644
index 00000000000..14358314b4b
--- /dev/null
+++ b/tests/Dataflow/TimingInvariantsTest.cpp
@@ -0,0 +1,1584 @@
+// Property / sweep tests for the temporal execution core: token_request
+// physical-time mapping, loop() subdivision, scenario buffer tiling,
+// quantification and metronome exactly-once semantics, in both directions.
+#include <ossia/detail/config.hpp>
+
+#include <ossia/dataflow/execution_state.hpp>
+#include <ossia/dataflow/graph_node.hpp>
+#include <ossia/dataflow/node_process.hpp>
+#include <ossia/dataflow/nodes/dummy.hpp>
+#include <ossia/dataflow/port.hpp>
+#include <ossia/dataflow/token_request.hpp>
+#include <ossia/editor/scenario/scenario.hpp>
+#include <ossia/editor/scenario/time_event.hpp>
+#include <ossia/editor/scenario/time_interval.hpp>
+#include <ossia/editor/scenario/time_sync.hpp>
+#include <ossia/editor/scenario/time_value.hpp>
+
+#include "include_catch.hpp"
+
+#include "../Editor/TestUtils.hpp"
+
+#include <algorithm>
+#include <cmath>
+#include <map>
+#include <vector>
+
+namespace
+{
+constexpr double flicks_ratio_48k = 48000. / ossia::flicks_per_second<double>;
+
+ossia::token_request
+tick(int64_t prev, int64_t date, int64_t offset, double speed) noexcept
+{
+  return ossia::token_request{
+      ossia::time_value{prev},   ossia::time_value{date}, ossia::time_value{1000000},
+      ossia::time_value{offset}, speed,                   ossia::time_signature{4, 4},
+      120.};
+}
+
+auto create_event(ossia::scenario& s)
+{
+  auto en = std::make_shared<ossia::time_sync>();
+  en->set_expression(ossia::expressions::make_expression_true());
+  auto ee = std::make_shared<ossia::time_event>(
+      ossia::time_event::exec_callback{}, *en,
+      ossia::expressions::make_expression_true());
+  en->insert(en->get_time_events().end(), ee);
+  s.add_time_sync(std::move(en));
+  return ee;
+}
+
+std::shared_ptr<ossia::time_interval> create_interval(
+    ossia::time_event& startEvent, ossia::time_event& endEvent, ossia::time_value d)
+{
+  auto ptr = ossia::time_interval::create({}, startEvent, endEvent, d, d, d);
+  ptr->add_time_process(std::make_shared<ossia::node_process>(
+      std::make_shared<ossia::nodes::dummy_node>()));
+  return ptr;
+}
+
+auto start_event(ossia::scenario& s)
+{
+  auto sn = s.get_start_time_sync();
+  return *sn->get_time_events().begin();
+}
+
+ossia::token_request default_request()
+{
+  ossia::token_request req;
+  req.tempo = 120;
+  req.speed = 1.;
+  req.signature = {4, 4};
+  return req;
+}
+
+//! What the audio callback hands the root of the tick tree: this tick stands
+//! for `frames` samples of the buffer, starting at 0.
+ossia::token_request root_request(int frames)
+{
+  ossia::token_request req = default_request();
+  req.start_sample = 0;
+  req.length_sample = frames;
+  return req;
+}
+
+void setup_state(ossia::execution_state& e, int bufferSize)
+{
+  e.bufferSize = bufferSize;
+  e.sampleRate = 48000;
+  e.modelToSamplesRatio = flicks_ratio_48k;
+  e.samplesToModelRatio = 1. / flicks_ratio_48k;
+}
+
+//! Records the buffer span every tick hands it, the way audio nodes do.
+struct probe_node final : public ossia::graph_node
+{
+  struct span
+  {
+    int64_t start{}, frames{};
+    int64_t prev_date{}, date{};
+  };
+  std::vector<span> spans;
+
+  probe_node()
+  {
+    m_inlets.push_back(new ossia::audio_inlet);
+    m_outlets.push_back(new ossia::audio_outlet);
+  }
+  std::string label() const noexcept override { return "probe"; }
+
+  void run(const ossia::token_request& tk, ossia::exec_state_facade st) noexcept override
+  {
+    auto [start, frames] = st.timings(tk);
+    spans.push_back({start, frames, tk.prev_date.impl, tk.date.impl});
+  }
+};
+
+//! The spans claimed on one tick must tile [0 ; expected_frames[ exactly.
+void require_exact_coverage(std::vector<probe_node::span> spans, int64_t expected_frames)
+{
+  std::sort(spans.begin(), spans.end(), [](const auto& a, const auto& b) {
+    return a.start < b.start;
+  });
+
+  int64_t expected = 0;
+  for(const auto& s : spans)
+  {
+    CAPTURE(s.start, s.frames, s.prev_date, s.date);
+    REQUIRE(s.frames > 0);
+    REQUIRE(s.start == expected);
+    expected = s.start + s.frames;
+  }
+  REQUIRE(expected == expected_frames);
+}
+}
+
+//------------------------------------------------------------------------------
+// 1. Physical-time mapping invariants, swept over speed / ratio / buffer size.
+//------------------------------------------------------------------------------
+
+TEST_CASE("sweep_physical_mapping_invariants", "sweep_physical_mapping_invariants")
+{
+  const double speeds[] = {1.,   -1.,  2.,       -2.,      0.5, -0.5,
+                           0.7,  -0.7, 1. / 3.,  -1. / 3., 2.5, -2.5,
+                           0.02, -0.02};
+  const double ratios[] = {1.0, flicks_ratio_48k, 44100. / ossia::flicks_per_second<double>};
+  const int buffer_sizes[] = {1, 7, 64, 512, 4096};
+
+  for(double speed : speeds)
+    for(double ratio : ratios)
+      for(int bs : buffer_sizes)
+      {
+        // Model time covered by one full buffer at this speed, the way
+        // time_interval::tick computes it.
+        const int64_t full_dt = int64_t(std::ceil(bs / ratio * std::abs(speed)));
+        if(full_dt <= 0)
+          continue;
+
+        // Split the buffer at several points, emulating an interval boundary:
+        // token A covers [0 ; cut[, token B covers [cut ; end[ of the tick.
+        for(double frac : {0.0, 0.25, 0.5, 0.75, 127. / 128.})
+        {
+          const int64_t cut = int64_t(full_dt * frac);
+          const int64_t d1 = cut, d2 = full_dt - cut;
+          const int64_t base = 100 * full_dt; // interval already ran for a while
+
+          std::vector<ossia::token_request> toks;
+          if(d1 > 0)
+            toks.push_back(
+                speed > 0 ? tick(base, base + d1, 0, speed)
+                          : tick(base + d1, base, 0, speed));
+          if(d2 > 0)
+            toks.push_back(
+                speed > 0 ? tick(base, base + d2, d1, speed)
+                          : tick(base + d2, base, d1, speed));
+
+          int64_t prev_end = 0;
+          for(const auto& t : toks)
+          {
+            CAPTURE(speed, ratio, bs, frac, t.prev_date.impl, t.date.impl,
+                    t.offset.impl);
+
+            const auto start = t.physical_start(ratio);
+            const auto wdur = t.physical_write_duration(ratio);
+            const auto rdur = t.physical_read_duration(ratio);
+
+            // Never negative, never starting past the buffer.
+            REQUIRE(start >= 0);
+            REQUIRE(wdur >= 0);
+            REQUIRE(rdur >= 0);
+            REQUIRE(start < bs);
+
+            // The span never leaks out of the buffer by more than the ceil()
+            // rounding of its own duration; the facade clamps the rest.
+            ossia::execution_state e;
+            e.bufferSize = bs;
+            e.sampleRate = 48000;
+            e.modelToSamplesRatio = ratio;
+            e.samplesToModelRatio = 1. / ratio;
+            const auto tm = ossia::exec_state_facade{&e}.timings(t);
+            if(std::abs(speed) > 0.01)
+            {
+              REQUIRE(tm.start_sample >= 0);
+              REQUIRE(tm.length >= 0);
+              REQUIRE(tm.start_sample + tm.length <= bs);
+              REQUIRE(tm.start_sample == start);
+              // A span that starts inside the buffer must not be clamped to
+              // nothing unless the tick itself is empty.
+              if(wdur > 0)
+                REQUIRE(tm.length > 0);
+            }
+
+            // Spans of consecutive tokens tile without holes: the second token
+            // starts within one sample of where the first ended (integer
+            // truncation of offset vs ceil of duration).
+            REQUIRE(std::abs(start - prev_end) <= 1);
+            prev_end = start + wdur;
+
+            // prev_date maps to the start of the span exactly.
+            REQUIRE(t.to_physical_time_in_tick(t.prev_date, ratio) == start);
+
+            // date maps to the end of the span, within the ceil() rounding.
+            const auto end_phys = t.to_physical_time_in_tick(t.date, ratio);
+            REQUIRE(end_phys >= start);
+            REQUIRE(std::abs(end_phys - (start + wdur)) <= 1);
+
+            // Monotonicity + range: every model time inside the tick maps into
+            // [start ; start + wdur], increasing along playback direction.
+            const int64_t lo = std::min(t.prev_date.impl, t.date.impl);
+            const int64_t hi = std::max(t.prev_date.impl, t.date.impl);
+            const int64_t step = std::max<int64_t>(1, (hi - lo) / 16);
+            int64_t prev_phys = start - 1;
+            for(int64_t m = 0; lo + m * step <= hi; m++)
+            {
+              const int64_t model
+                  = speed > 0 ? lo + m * step : hi - m * step;
+              const auto p = t.to_physical_time_in_tick(ossia::time_value{model}, ratio);
+              REQUIRE(p >= start);
+              REQUIRE(p <= start + wdur);
+              REQUIRE(p >= prev_phys);
+              prev_phys = p;
+
+              // Round-trip: from_physical(to_physical(m)) stays within one
+              // physical sample's worth of model time of the tick. (The
+              // offset is not necessarily sample-aligned, so the truncation
+              // can push the result up to one sample outside on either end.)
+              const int64_t one_sample_model
+                  = int64_t(std::ceil(std::abs(speed) / ratio));
+              const auto back = t.from_physical_time_in_tick(p, ratio);
+              REQUIRE(back.impl >= lo - one_sample_model);
+              REQUIRE(back.impl <= hi + one_sample_model);
+              // Each direction truncates once, so the double round-trip can
+              // lose up to two samples at fractional speeds.
+              const auto p2 = t.to_physical_time_in_tick(back, ratio);
+              REQUIRE(std::abs(p2 - p) <= 2);
+            }
+          }
+        }
+      }
+}
+
+//------------------------------------------------------------------------------
+// 2. loop() subdivision, swept.
+//------------------------------------------------------------------------------
+
+TEST_CASE("sweep_loop_subdivision", "sweep_loop_subdivision")
+{
+  for(int64_t loop_dur : {1, 3, 7, 100, 1000})
+    for(int64_t start_offset : {0, 50, 12345})
+      for(int64_t from_rel : {0, 1, 3, 99, 100, 101, 250, 999, 1000, 1001, 2500})
+        for(int64_t dt : {1, 2, 5, 99, 100, 101, 333, 1000, 1001, 3000})
+          for(int direction : {+1, -1})
+          {
+            const int64_t from = from_rel;
+            const int64_t to = from + direction * dt;
+            if(to < 0)
+              continue;
+
+            CAPTURE(loop_dur, start_offset, from, to, direction);
+
+            const auto t = tick(from, to, 0, double(direction));
+
+            int64_t emitted = 0;
+            int64_t expected_offset = 0;
+            int64_t transports = 0;
+            int64_t pieces = 0;
+            bool overflow = false;
+
+            t.loop(
+                ossia::time_value{start_offset}, ossia::time_value{loop_dur},
+                [&](const ossia::token_request& sub) {
+              if(++pieces > 4000)
+              {
+                overflow = true;
+                return;
+              }
+              const int64_t d = (sub.date - sub.prev_date).impl;
+
+              // Direction preserved, never an empty piece.
+              REQUIRE(d != 0);
+              REQUIRE((d < 0) == (direction < 0));
+
+              // Stays inside [start_offset ; start_offset + loop_dur].
+              REQUIRE(sub.prev_date.impl >= start_offset);
+              REQUIRE(sub.prev_date.impl <= start_offset + loop_dur);
+              REQUIRE(sub.date.impl >= start_offset);
+              REQUIRE(sub.date.impl <= start_offset + loop_dur);
+
+              // Contiguous layout in the buffer.
+              REQUIRE(sub.offset.impl == expected_offset);
+              expected_offset += d < 0 ? -d : d;
+
+              emitted += d;
+                },
+                [&](const ossia::time_value&) { transports++; });
+
+            REQUIRE(!overflow);
+            // Conservation: exactly the requested amount of time was emitted.
+            REQUIRE(emitted == direction * dt);
+            // A tick spanning n loop points needs at most n + 1 pieces.
+            REQUIRE(pieces <= dt / loop_dur + 2);
+          }
+}
+
+//------------------------------------------------------------------------------
+// 3. Scenario buffer tiling: chains of intervals, both directions, several
+//    buffer sizes, boundaries on and off buffer edges, direction changes.
+//------------------------------------------------------------------------------
+
+namespace
+{
+struct tiling_setup
+{
+  ossia::execution_state e;
+  root_scenario s;
+  std::vector<std::shared_ptr<probe_node>> probes;
+  std::vector<std::shared_ptr<ossia::time_interval>> intervals;
+  int64_t buffer_flicks{};
+  int frames{};
+
+  tiling_setup(int bs, const std::vector<int64_t>& durations_in_buffer_8ths)
+  {
+    setup_state(e, bs);
+    frames = bs;
+    buffer_flicks = int64_t(bs / flicks_ratio_48k);
+
+    std::vector<std::shared_ptr<ossia::time_event>> evs;
+    evs.push_back(start_event(*s.scenario));
+    for(std::size_t i = 0; i < durations_in_buffer_8ths.size(); i++)
+      evs.push_back(create_event(*s.scenario));
+
+    for(std::size_t i = 0; i < durations_in_buffer_8ths.size(); i++)
+    {
+      const auto dur
+          = ossia::time_value{durations_in_buffer_8ths[i] * buffer_flicks / 8};
+      auto itv = create_interval(*evs[i], *evs[i + 1], dur);
+      s.scenario->add_time_interval(itv);
+      intervals.push_back(itv);
+      auto p = std::make_shared<probe_node>();
+      probes.push_back(p);
+      itv->add_time_process(std::make_shared<ossia::node_process>(p));
+    }
+
+    s.interval->start();
+    s.interval->tick_current(ossia::time_value{}, {});
+  }
+
+  std::vector<probe_node::span> do_tick()
+  {
+    std::vector<probe_node::span> all;
+    for(auto& p : probes)
+    {
+      p->requested_tokens.clear();
+      p->spans.clear();
+    }
+    s.interval->tick(ossia::time_value{buffer_flicks}, root_request(frames));
+    for(auto& p : probes)
+    {
+      for(auto& tk : p->requested_tokens)
+        p->run(tk, {&e});
+      all.insert(all.end(), p->spans.begin(), p->spans.end());
+    }
+    return all;
+  }
+};
+}
+
+TEST_CASE("sweep_scenario_tiling_speed_1", "sweep_scenario_tiling_speed_1")
+{
+  // Durations in 1/8ths of a buffer. Mixes: boundaries exactly on buffer
+  // edges (8, 16), mid-buffer (4, 12, 20), shorter than a buffer (3, 5),
+  // and longer runs (27).
+  const std::vector<std::vector<int64_t>> layouts = {
+      {8, 8, 8, 8, 64},         // all boundaries on buffer edges
+      {12, 12, 12, 12, 64},     // all mid-buffer
+      {3, 3, 3, 3, 3, 3, 64},   // several boundaries per buffer
+      {5, 27, 4, 16, 64},       // mixed
+      {16, 3, 5, 8, 64},        //
+  };
+
+  for(int bs : {16, 64, 256})
+  {
+    for(const auto& layout : layouts)
+    {
+      CAPTURE(bs, layout.size());
+      tiling_setup ts(bs, layout);
+
+      int64_t total_8ths = 0;
+      for(auto d : layout)
+        total_8ths += d;
+
+      // Enough forward ticks to get inside the last interval but not past it.
+      const int fwd_ticks = int(total_8ths / 8) - 3;
+      int64_t net_buffers = 0; // playhead position in buffers
+
+      // Interval boundaries, in eighths of a buffer. A backward tick taken
+      // while an interval sits exactly at its own start currently stalls
+      // (see scenario_backward_stalls_on_exact_boundary below), so the
+      // direction changes in this sweep avoid landing exactly on one.
+      std::vector<int64_t> boundaries;
+      {
+        int64_t acc = 0;
+        for(auto d : layout)
+        {
+          acc += d;
+          boundaries.push_back(acc);
+        }
+      }
+      auto on_boundary = [&] {
+        return std::find(boundaries.begin(), boundaries.end(), net_buffers * 8)
+               != boundaries.end();
+      };
+
+      for(int i = 0; i < fwd_ticks; i++)
+      {
+        CAPTURE("forward", i);
+        const auto all = ts.do_tick();
+        net_buffers++;
+        require_exact_coverage(all, bs);
+      }
+
+      // Now rewind across everything, checking tiling each tick.
+      while(on_boundary())
+      {
+        require_exact_coverage(ts.do_tick(), bs);
+        net_buffers++;
+      }
+      ts.s.interval->set_speed(-1.);
+      for(int i = 0; i + 1 < net_buffers; i++)
+      {
+        CAPTURE("backward", i);
+        const auto all = ts.do_tick();
+        require_exact_coverage(all, bs);
+      }
+      net_buffers = 1;
+
+      // Direction changes mid-run.
+      ts.s.interval->set_speed(1.);
+      for(int i = 0; i < 2; i++)
+      {
+        CAPTURE("fwd2", i);
+        require_exact_coverage(ts.do_tick(), bs);
+        net_buffers++;
+      }
+      while(on_boundary())
+      {
+        require_exact_coverage(ts.do_tick(), bs);
+        net_buffers++;
+      }
+      ts.s.interval->set_speed(-1.);
+      CAPTURE("bwd2");
+      require_exact_coverage(ts.do_tick(), bs);
+      net_buffers--;
+      ts.s.interval->set_speed(1.);
+      CAPTURE("fwd3");
+      require_exact_coverage(ts.do_tick(), bs);
+      net_buffers++;
+    }
+  }
+}
+
+TEST_CASE("scenario_tiling_root_speed_scaling", "scenario_tiling_root_speed_scaling")
+{
+  // |speed| != 1 on the root transport: the scenario covers more (or less)
+  // model time per callback, but every audio buffer must still be tiled
+  // exactly, including on ticks where an interval boundary is crossed. The
+  // awkward speeds are the point: their product with the buffer length is
+  // not a whole number of flicks, so any reconstruction of the span from the
+  // flick-quantised model dates comes out a sample short.
+  struct
+  {
+    double speed;
+    int fwd_ticks; // chosen so no direction change lands exactly on a boundary
+  } cases[] = {{2., 2},      {0.5, 5},     {1.234, 2},    {0.987654, 3},
+               {1.5849, 2},  {1. / 3., 8}, {0.777777, 3}, {2.718281828, 2},
+               {1.000001, 2}};
+
+  for(int bs : {16, 64, 256, 512})
+  {
+    for(auto c : cases)
+    {
+      CAPTURE(bs, c.speed, c.fwd_ticks);
+      // Boundaries at 12, 24, 36, 48 eighths, i.e. 1.5, 3, 4.5, 6 buffers:
+      // mid-buffer at every speed used here.
+      tiling_setup ts(bs, {12, 12, 12, 12, 128});
+
+      ts.s.interval->set_speed(c.speed);
+      for(int i = 0; i < c.fwd_ticks; i++)
+      {
+        CAPTURE("forward", i);
+        require_exact_coverage(ts.do_tick(), bs);
+      }
+
+      ts.s.interval->set_speed(-c.speed);
+      for(int i = 0; i + 1 < c.fwd_ticks; i++)
+      {
+        CAPTURE("backward", i);
+        require_exact_coverage(ts.do_tick(), bs);
+      }
+
+      // The playhead came back to one tick's worth from the start: the
+      // out-and-back must not drift by more than the one flick the final
+      // floor can shave off the carried fraction.
+      const double exact = double(ts.buffer_flicks) * c.speed;
+      CAPTURE(exact, ts.s.interval->get_date().impl);
+      REQUIRE(std::abs(double(ts.s.interval->get_date().impl) - exact) <= 1.);
+    }
+  }
+}
+
+TEST_CASE("scenario_tiling_child_speed_scaling", "scenario_tiling_child_speed_scaling")
+{
+  // |speed| != 1 on the intervals themselves, with the root transport at 1.
+  // An interval's own speed changes how fast it consumes its own duration; it
+  // must not change where in the audio buffer the interval writes. Distinct
+  // from scenario_tiling_root_speed_scaling, which only varies the root.
+  const int bs = 64;
+
+  // Speed 3 puts boundaries between two samples (a 1-buffer interval ends at
+  // sample 21.33), which only tiles once every span is a difference of the
+  // same map.
+  const std::vector<std::vector<int64_t>> layouts = {
+      {8, 8, 8, 512},
+      {12, 12, 12, 512},
+      {5, 11, 7, 512},
+  };
+
+  // 1.234 and 0.987654 are the awkward ones: a child interval consuming its
+  // own duration at a rate whose product with the buffer is not a whole
+  // number of flicks must still hand over at the exact sample it stops at.
+  for(double speed : {2., 0.5, 0.25, 3., 1.234, 0.987654})
+  {
+    for(const auto& layout : layouts)
+    {
+      CAPTURE(speed, layout[0], layout[1], layout[2]);
+      tiling_setup ts(bs, layout);
+      for(auto& itv : ts.intervals)
+        itv->set_speed(speed);
+
+      for(int i = 0; i < 6; i++)
+      {
+        CAPTURE("forward", i);
+        require_exact_coverage(ts.do_tick(), bs);
+      }
+
+      // And back out through the same boundaries.
+      ts.s.interval->set_speed(-1.);
+      for(int i = 0; i + 1 < 6; i++)
+      {
+        CAPTURE("backward", i);
+        require_exact_coverage(ts.do_tick(), bs);
+      }
+    }
+  }
+}
+
+TEST_CASE(
+    "quantification_grid_restarts_at_each_bar",
+    "quantification_grid_restarts_at_each_bar")
+{
+  // 7/8 is 3.5 quarters, which a half-note grid (rate 2, a point every two
+  // quarters) does not divide. Computing the grid once from the bar the tick
+  // started in carries that bar's phase across the bar line: it invents points
+  // off the grid and skips the bar lines, which are always grid points.
+  // 1000 flicks per quarter here, so a date reads as its musical position.
+  auto t = tick(0, 8000, 0, 1.);
+  t.signature = {7, 8};
+  t.musical_start_last_signature = 0.;
+  t.musical_start_last_bar = 0.;
+  t.musical_start_position = 0.;
+  t.musical_end_last_bar = 7.;
+  t.musical_end_position = 8.;
+
+  // Bar lines at 0, 3.5 and 7; one half-note into each of them at 2 and 5.5.
+  // 9 would be the next, past the end of the tick.
+  const std::vector<double> expected{0., 2., 3.5, 5.5, 7.};
+  const std::vector<int64_t> expected_index{0, 1, 0, 1, 0};
+
+  const auto pts = t.get_quantification_dates(2.);
+  REQUIRE(pts.size() == expected.size());
+  for(std::size_t i = 0; i < expected.size(); i++)
+  {
+    CAPTURE(i, pts[i].date.impl, pts[i].index);
+    REQUIRE(std::abs(double(pts[i].date.impl) / 1000. - expected[i]) < 0.001);
+    // The index counts divisions from the bar the point falls in, so it
+    // restarts at every bar line too.
+    REQUIRE(pts[i].index == expected_index[i]);
+  }
+
+  // Rewinding over the same ground reports the same points, in reverse.
+  auto b = tick(8000, 0, 0, -1.);
+  b.signature = {7, 8};
+  b.musical_start_last_signature = 0.;
+  b.musical_start_last_bar = 7.;
+  b.musical_start_position = 8.;
+  b.musical_end_last_bar = 0.;
+  b.musical_end_position = 0.;
+
+  const auto rpts = b.get_quantification_dates(2.);
+  std::vector<double> rgot;
+  for(const auto& p : rpts)
+    rgot.push_back(double(p.date.impl) / 1000.);
+  CAPTURE(rgot.size());
+  // Same grid, walked downwards; the point on the tick's own end is excluded
+  // the same way the forward walk excludes the one on its end.
+  REQUIRE(rgot.size() >= 4);
+  for(std::size_t i = 1; i < rgot.size(); i++)
+    REQUIRE(rgot[i] < rgot[i - 1]);
+  for(double g : rgot)
+  {
+    const bool on_grid
+        = std::any_of(expected.begin(), expected.end(), [&](double e) {
+            return std::abs(e - g) < 0.001;
+          });
+    CAPTURE(g);
+    REQUIRE(on_grid);
+  }
+}
+
+TEST_CASE(
+    "quantification_singular_agrees_with_plural",
+    "quantification_singular_agrees_with_plural")
+{
+  // get_quantification_dates documents that its first element is what
+  // get_quantification_date returns. Quantized triggers use the singular one
+  // and pattern quantization the plural, so if they disagree the same score
+  // fires notes and events on different grids.
+  for(auto sig : {ossia::time_signature{4, 4}, ossia::time_signature{7, 8},
+                  ossia::time_signature{5, 4}})
+  {
+    for(double rate : {1., 2., 4.})
+    {
+      for(int step = 0; step < 40; step++)
+      {
+        const double start = step * 0.35;
+        const double end = start + 0.4;
+
+        auto t = tick(int64_t(start * 1000), int64_t(end * 1000), 0, 1.);
+        t.signature = sig;
+        t.musical_start_last_signature = 0.;
+        const double qpb = 4. * sig.upper / sig.lower;
+        t.musical_start_last_bar = std::floor(start / qpb) * qpb;
+        t.musical_start_position = start;
+        t.musical_end_last_bar = std::floor(end / qpb) * qpb;
+        t.musical_end_position = end;
+
+        CAPTURE(sig.upper, sig.lower, rate, start, end);
+        const auto plural = t.get_quantification_dates(rate);
+        const auto singular = t.get_quantification_date(rate);
+
+        REQUIRE(singular.has_value() == !plural.empty());
+        if(singular && !plural.empty())
+          REQUIRE(singular->impl == plural[0].date.impl);
+      }
+    }
+  }
+}
+
+TEST_CASE("transport_frames_follow_the_transport", "transport_frames_follow_the_transport")
+{
+  // processed_frames counts audio through the node and only rises, which is
+  // right for a steady counter. The position handed to plug-ins is not that: it
+  // has to come back down when the timeline does, or a rewind leaves every
+  // tempo-synced plug-in believing the playhead is somewhere it is not.
+  ossia::execution_state e;
+  setup_state(e, 64);
+  probe_node n;
+
+  const int64_t buffer_flicks = int64_t(64 / flicks_ratio_48k);
+  const int n_fwd = 8;
+
+  for(int i = 0; i < n_fwd; i++)
+    n.process_time(tick(i * buffer_flicks, (i + 1) * buffer_flicks, 0, 1.), e);
+
+  // Reported for the first sample of each tick, so the last one starts a buffer
+  // short of where it ends.
+  REQUIRE(n.transport_frames() == int64_t(n_fwd - 1) * 64);
+  REQUIRE(n.processed_frames() == int64_t(n_fwd) * 64);
+
+  // Rewind over the same ground: the playhead retraces its steps. It starts
+  // from where the forward run ended, which is a buffer past the last tick's
+  // own start.
+  int64_t prev = int64_t(n_fwd) * 64;
+  for(int i = n_fwd - 1; i >= 0; i--)
+  {
+    n.process_time(tick((i + 1) * buffer_flicks, i * buffer_flicks, 0, -1.), e);
+    CAPTURE(i, n.transport_frames(), prev);
+    REQUIRE(n.transport_frames() <= prev);
+    prev = n.transport_frames();
+  }
+
+  // Back to the buffer it started from - the first tick of the rewind began one
+  // buffer past the end, and the last one begins one buffer past zero.
+  REQUIRE(n.transport_frames() == 64);
+  // Meanwhile the steady counter kept counting the audio it rendered.
+  REQUIRE(n.processed_frames() == int64_t(2 * n_fwd) * 64);
+}
+
+TEST_CASE("interval_date_accumulates_exactly", "interval_date_accumulates_exactly")
+{
+  // Awkward speeds do not multiply out to whole flicks. Rounding each tick up
+  // put the date up to 2.16M flicks (147 samples) ahead over an hour; carrying
+  // the fraction keeps it on the exact value.
+  const int64_t buffer_flicks = int64_t(64 / flicks_ratio_48k);
+
+  for(double speed : {1., 0.5, 2., 1. / 3., 0.7, 1.234, 0.987654, 1.5849})
+  {
+    CAPTURE(speed);
+    ossia::execution_state e;
+    setup_state(e, 64);
+    root_scenario s;
+    auto itv = create_interval(
+        *start_event(*s.scenario), *create_event(*s.scenario), ossia::Infinite);
+    s.scenario->add_time_interval(itv);
+    itv->set_speed(speed);
+    s.interval->start();
+    s.interval->tick_current(ossia::time_value{}, {});
+
+    const int n = 2000;
+    for(int i = 0; i < n; i++)
+      s.interval->tick(ossia::time_value{buffer_flicks}, default_request());
+
+    // Never more than the one flick the final floor can shave off.
+    const double exact = double(buffer_flicks) * n * speed;
+    CAPTURE(exact, itv->get_date().impl);
+    REQUIRE(std::abs(double(itv->get_date().impl) - exact) <= 1.);
+  }
+}
+
+TEST_CASE("interval_progress_at_extreme_speeds", "interval_progress_at_extreme_speeds")
+{
+  const int64_t buffer_flicks = int64_t(64 / flicks_ratio_48k);
+
+  // Far below one flick per tick: no single tick can advance, but the carried
+  // fraction has to make it move eventually rather than stall forever.
+  {
+    ossia::execution_state e;
+    setup_state(e, 64);
+    root_scenario s;
+    auto itv = create_interval(
+        *start_event(*s.scenario), *create_event(*s.scenario), ossia::Infinite);
+    s.scenario->add_time_interval(itv);
+    itv->set_speed(1e-9);
+    s.interval->start();
+    s.interval->tick_current(ossia::time_value{}, {});
+
+    for(int i = 0; i < 2000; i++)
+      s.interval->tick(ossia::time_value{buffer_flicks}, default_request());
+
+    REQUIRE(itv->get_date() > ossia::time_value{0});
+    // And it did not run a million times too fast, as rounding up did.
+    REQUIRE(itv->get_date() < ossia::time_value{100});
+  }
+
+  // Speed 0 is the one case that must not move at all.
+  {
+    ossia::execution_state e;
+    setup_state(e, 64);
+    root_scenario s;
+    auto itv = create_interval(
+        *start_event(*s.scenario), *create_event(*s.scenario), ossia::Infinite);
+    s.scenario->add_time_interval(itv);
+    itv->set_speed(0.);
+    s.interval->start();
+    s.interval->tick_current(ossia::time_value{}, {});
+
+    for(int i = 0; i < 100; i++)
+      s.interval->tick(ossia::time_value{buffer_flicks}, default_request());
+
+    REQUIRE(itv->get_date() == ossia::time_value{0});
+  }
+}
+
+TEST_CASE(
+    "scenario_tiling_tempo_under_parent_speed",
+    "scenario_tiling_tempo_under_parent_speed")
+{
+  // A tempo-locked interval advances at its own tempo whatever the transport
+  // does: tick_offset divides by the parent speed. The max-duration clamp has
+  // to use that same factor, or it fires early and hands whatever follows a
+  // spurious overtick.
+  const int bs = 64;
+  tiling_setup ts(bs, {12, 12, 512});
+
+  ossia::tempo_curve flat;
+  flat.set_x0(0);
+  flat.set_y0(ossia::root_tempo);
+  for(auto& itv : ts.intervals)
+    itv->set_tempo_curve(flat);
+
+  ts.s.interval->set_speed(2.);
+  for(int i = 0; i < 6; i++)
+  {
+    CAPTURE("forward", i);
+    require_exact_coverage(ts.do_tick(), bs);
+  }
+}
+
+TEST_CASE("scenario_nested_tiling", "scenario_nested_tiling")
+{
+  // A scenario inside an interval inside a scenario: the inner intervals must
+  // tile the audio buffer exactly like the outer ones, forward and backward,
+  // including when the outer interval starts mid-buffer.
+  const int bs = 64;
+  ossia::execution_state e;
+  setup_state(e, bs);
+  const int64_t buffer_flicks = int64_t(bs / flicks_ratio_48k);
+
+  root_scenario s;
+  auto se = start_event(*s.scenario);
+  auto e1 = create_event(*s.scenario);
+  auto e2 = create_event(*s.scenario);
+
+  // Outer chain: c0 = half a buffer, then c_mid which hosts the inner
+  // scenario for 8 buffers.
+  auto c0 = create_interval(*se, *e1, ossia::time_value{buffer_flicks / 2});
+  auto c_mid = create_interval(*e1, *e2, ossia::time_value{8 * buffer_flicks});
+  s.scenario->add_time_interval(c0);
+  s.scenario->add_time_interval(c_mid);
+
+  auto p0 = std::make_shared<probe_node>();
+  c0->add_time_process(std::make_shared<ossia::node_process>(p0));
+
+  // Inner scenario: two intervals of 1.25 buffers each, then a long tail.
+  auto inner = std::make_shared<ossia::scenario>();
+  {
+    auto sn = inner->get_start_time_sync();
+    auto ev = std::make_shared<ossia::time_event>(
+        ossia::time_event::exec_callback{}, *sn,
+        ossia::expressions::make_expression_true());
+    sn->insert(sn->get_time_events().end(), ev);
+  }
+  auto ise = start_event(*inner);
+  auto ie1 = create_event(*inner);
+  auto ie2 = create_event(*inner);
+  auto ie3 = create_event(*inner);
+  auto ic0 = create_interval(*ise, *ie1, ossia::time_value{5 * buffer_flicks / 4});
+  auto ic1 = create_interval(*ie1, *ie2, ossia::time_value{5 * buffer_flicks / 4});
+  auto ic2 = create_interval(*ie2, *ie3, ossia::time_value{16 * buffer_flicks});
+  inner->add_time_interval(ic0);
+  inner->add_time_interval(ic1);
+  inner->add_time_interval(ic2);
+
+  auto ip0 = std::make_shared<probe_node>();
+  auto ip1 = std::make_shared<probe_node>();
+  auto ip2 = std::make_shared<probe_node>();
+  ic0->add_time_process(std::make_shared<ossia::node_process>(ip0));
+  ic1->add_time_process(std::make_shared<ossia::node_process>(ip1));
+  ic2->add_time_process(std::make_shared<ossia::node_process>(ip2));
+
+  c_mid->add_time_process(inner);
+
+  s.interval->start();
+  s.interval->tick_current(ossia::time_value{}, {});
+
+  const auto probes = {p0, ip0, ip1, ip2};
+  auto do_tick = [&] {
+    std::vector<probe_node::span> all;
+    for(auto& p : probes)
+    {
+      p->requested_tokens.clear();
+      p->spans.clear();
+    }
+    s.interval->tick(ossia::time_value{buffer_flicks}, root_request(bs));
+    for(auto& p : probes)
+    {
+      for(auto& tk : p->requested_tokens)
+        p->run(tk, {&e});
+      all.insert(all.end(), p->spans.begin(), p->spans.end());
+    }
+    return all;
+  };
+
+  // Forward: tick 0 is split between c0 and the inner scenario's first
+  // interval (which starts mid-buffer); the inner boundaries then fall at
+  // 0.5 + 1.25 k buffers, i.e. mid-buffer again.
+  for(int i = 0; i < 4; i++)
+  {
+    CAPTURE("forward", i);
+    const auto all = do_tick();
+    require_exact_coverage(all, bs);
+  }
+  // We are at 4 buffers: c_mid at 3.5 buffers, inside ic2 (starts at 2.5).
+  REQUIRE(!ip2->spans.empty());
+
+  // Backward across both inner boundaries and back out into c0.
+  s.interval->set_speed(-1.);
+  for(int i = 0; i < 3; i++)
+  {
+    CAPTURE("backward", i);
+    const auto all = do_tick();
+    require_exact_coverage(all, bs);
+  }
+  // The tick that crosses back into c0 covers the buffer with pieces of the
+  // inner first interval and of c0.
+  {
+    CAPTURE("backward-out");
+    const auto all = do_tick();
+    require_exact_coverage(all, bs);
+    REQUIRE(!p0->spans.empty());
+    REQUIRE(!ip0->spans.empty());
+  }
+}
+
+TEST_CASE("scenario_rewind_to_zero_partial_buffer", "scenario_rewind_to_zero_partial_buffer")
+{
+  // Rewinding past t=0: the tick that crosses zero only covers the part of
+  // the buffer that maps to t >= 0, and the transport must stay clamped at 0.
+  const int bs = 64;
+  tiling_setup ts(bs, {24, 64});
+
+  // Half a buffer forward (as when the transport starts mid-callback), then a
+  // full one: the playhead sits at 1.5 buffers, all inside the first interval.
+  {
+    ts.s.interval->tick(
+        ossia::time_value{ts.buffer_flicks / 2}, root_request(bs / 2));
+    require_exact_coverage(ts.do_tick(), bs);
+  }
+  ts.s.interval->set_speed(-1.);
+
+  // First backward tick: full buffer.
+  require_exact_coverage(ts.do_tick(), bs);
+
+  // Second backward tick: covers only half a buffer (t=0 reached mid-buffer).
+  {
+    const auto all = ts.do_tick();
+    int64_t covered = 0;
+    for(auto& sp : all)
+    {
+      REQUIRE(sp.start == 0);
+      covered += sp.frames;
+      REQUIRE(sp.date >= 0);
+    }
+    REQUIRE(covered == bs / 2);
+    REQUIRE(ts.s.interval->get_date() == ossia::time_value{0});
+  }
+
+  // Further backward ticks: nothing, and no negative dates anywhere.
+  {
+    const auto all = ts.do_tick();
+    for(auto& sp : all)
+    {
+      REQUIRE(sp.frames == 0);
+      REQUIRE(sp.date >= 0);
+    }
+    REQUIRE(ts.s.interval->get_date() == ossia::time_value{0});
+  }
+
+  // And forward again resumes instantly from 0.
+  ts.s.interval->set_speed(1.);
+  require_exact_coverage(ts.do_tick(), bs);
+}
+
+TEST_CASE(
+    "scenario_backward_resumes_on_exact_boundary",
+    "[scenario_backward_resumes_on_exact_boundary]")
+{
+  // KNOWN BUG (backward playback): when the playhead sits exactly on an
+  // interval boundary - the next interval started, its date is exactly 0 -
+  // and the direction flips to backward, run_interval_backward has to cascade
+  // for an interval already sitting at 0 - stopping it and re-starting the
+  // previous one. Bailing out instead left the tick producing no audio at all,
+  // with the playhead stuck for the rest of the rewind.
+  const int bs = 64;
+  tiling_setup ts(bs, {8, 8, 64});
+
+  // Two forward ticks: the playhead is exactly on the boundary between the
+  // second and third interval, the third interval just started at date 0.
+  require_exact_coverage(ts.do_tick(), bs);
+  require_exact_coverage(ts.do_tick(), bs);
+
+  // Rewind: this buffer must be covered by the second interval.
+  ts.s.interval->set_speed(-1.);
+  const auto all = ts.do_tick();
+  require_exact_coverage(all, bs);
+
+  // And rewinding must actually move the playhead back.
+  REQUIRE(!all.empty());
+}
+
+TEST_CASE("scenario_playhead_returns_after_round_trip", "scenario_playhead_returns_after_round_trip")
+{
+  // N buffers forward then N buffers backward at |speed| = 1 must return the
+  // playhead exactly to where it started: no drift, sample-accurate.
+  const int bs = 64;
+  tiling_setup ts(bs, {12, 12, 12, 12, 64});
+
+  const auto start_date = ts.s.interval->get_date();
+  for(int i = 0; i < 7; i++)
+    ts.do_tick();
+  const auto mid_date = ts.s.interval->get_date();
+  REQUIRE((mid_date - start_date).impl == 7 * ts.buffer_flicks);
+
+  ts.s.interval->set_speed(-1.);
+  for(int i = 0; i < 7; i++)
+    ts.do_tick();
+  REQUIRE(ts.s.interval->get_date() == start_date);
+}
+
+//------------------------------------------------------------------------------
+// 4. Quantification: exactly-once across consecutive ticks, forward and
+//    backward, odd signatures, tick sizes that don't divide the grid.
+//------------------------------------------------------------------------------
+
+namespace
+{
+//! Drives a real time_interval with a signature map so that tick_impl computes
+//! the musical positions, and collects its tokens.
+struct musical_setup
+{
+  root_scenario s;
+  std::shared_ptr<probe_node> probe = std::make_shared<probe_node>();
+  std::shared_ptr<ossia::time_interval> itv;
+  double quarter_dur;
+
+  musical_setup(ossia::time_signature sig, double quarter_duration)
+      : quarter_dur{quarter_duration}
+  {
+    auto se = start_event(*s.scenario);
+    auto ee = create_event(*s.scenario);
+    itv = create_interval(*se, *ee, ossia::time_value{1 << 30});
+    ossia::time_signature_map m;
+    m[ossia::time_value{0}] = sig;
+    itv->set_time_signature_map(m);
+    itv->set_quarter_duration(quarter_duration);
+    s.scenario->add_time_interval(itv);
+    itv->add_time_process(std::make_shared<ossia::node_process>(probe));
+
+    s.interval->start();
+    s.interval->tick_current(ossia::time_value{}, {});
+  }
+
+  std::vector<ossia::token_request> do_tick(int64_t amount)
+  {
+    probe->requested_tokens.clear();
+    s.interval->tick(ossia::time_value{amount}, default_request());
+    return {probe->requested_tokens.begin(), probe->requested_tokens.end()};
+  }
+};
+}
+
+TEST_CASE("sweep_quantification_exactly_once", "sweep_quantification_exactly_once")
+{
+  const ossia::time_signature sigs[] = {{4, 4}, {7, 8}, {5, 4}, {3, 4}};
+  const double rates[] = {1., 2., 4., 8., 16., 0.5};
+  const double quarter = 1000.;
+
+  for(auto sig : sigs)
+    for(double rate : rates)
+      for(int64_t tick_size : {313, 1000, 1700, 4096})
+      {
+        CAPTURE(sig.upper, sig.lower, rate, tick_size);
+
+        musical_setup ms(sig, quarter);
+
+        // The reference grid, in model time. For rates of a bar or longer the
+        // grid is anchored at the last signature change (t=0 here); for
+        // shorter rates it restarts at every bar, so in signatures whose bar
+        // is not a multiple of the division (7/8 vs a half note) the last
+        // point of a bar and the first point of the next are closer than one
+        // division. The exactly-once property is on this grid.
+        const double quarters_per_bar = 4. * sig.upper / sig.lower;
+        const double unit_quarters
+            = rate <= 1. ? quarters_per_bar / rate : 4. / rate;
+        const int64_t unit_model = int64_t(unit_quarters * quarter);
+        const int64_t bar_model = int64_t(quarters_per_bar * quarter);
+        const int n_ticks = int(64000 / tick_size) + 1;
+        const int64_t total_span = int64_t(n_ticks) * tick_size;
+
+        // The full grid, in model time: for rates of a bar or longer it is
+        // anchored at the last signature change (t=0 here); for shorter rates
+        // it restarts at every bar.
+        std::vector<int64_t> grid;
+        if(rate <= 1.)
+        {
+          for(int64_t p = 0; p <= total_span; p += unit_model)
+            grid.push_back(p);
+        }
+        else
+        {
+          for(int64_t bar = 0; bar <= total_span; bar += bar_model)
+          {
+            grid.push_back(bar);
+            for(int64_t p = bar + unit_model;
+                p < bar + bar_model && p <= total_span; p += unit_model)
+              grid.push_back(p);
+          }
+        }
+
+        // When the bar length is a multiple of the division this grid is
+        // uniform and the engine reports it exactly, in both directions.
+        //
+        // When it is not (7/8 against a half- or quarter-note grid), the
+        // engine subdivides from the bar in effect at the tick's *start*, so
+        // around a bar line the reported points depend on how ticks align
+        // with it: going forward the bar-start point is usually skipped (the
+        // old TODO in get_quantification_date_for_shorter_than_bars), going
+        // backward it is reported as k=0 of the new bar, and a tick reaching
+        // more than one division past a bar line interpolates from the stale
+        // origin. For those configurations only the direction-independent
+        // invariants are checked (inside the tick, no duplicates, physical
+        // position in range); the strict exactly-once grid comparison is done
+        // whenever the grid is uniform.
+        const bool aligned = rate <= 1. || (bar_model % unit_model == 0);
+        const bool strict_f = aligned;
+        // Backward reports the full grid as long as no tick can span two grid
+        // points (the smallest gap is between the last subdivision of a bar
+        // and the next bar line).
+        int64_t min_gap = unit_model;
+        for(std::size_t i = 1; i < grid.size(); i++)
+          min_gap = std::min(min_gap, grid[i] - grid[i - 1]);
+        const bool strict_b = aligned || tick_size <= min_gap;
+
+        const auto matches = [](int64_t a, int64_t b) {
+          return std::abs(a - b) <= 2;
+        };
+
+        // ---- Forward: every grid date in increasing order, exactly once.
+        std::vector<int64_t> seen;
+        for(int i = 0; i < n_ticks; i++)
+        {
+          for(const auto& tk : ms.do_tick(tick_size))
+          {
+            if(tk.date == tk.prev_date)
+              continue;
+            for(const auto& q : tk.get_quantification_dates(rate))
+            {
+              CAPTURE(i, tk.prev_date.impl, tk.date.impl, q.date.impl, q.index);
+
+              // The reported date lies inside the tick (forward: [prev; date[).
+              REQUIRE(q.date >= tk.prev_date);
+              REQUIRE(q.date < tk.date);
+
+              // It maps to a sample inside the tick's span.
+              const auto p = tk.to_physical_time_in_tick(q.date, flicks_ratio_48k);
+              REQUIRE(p >= tk.physical_start(flicks_ratio_48k));
+              REQUIRE(
+                  p <= tk.physical_start(flicks_ratio_48k)
+                           + tk.physical_write_duration(flicks_ratio_48k));
+
+              seen.push_back(q.date.impl);
+            }
+          }
+        }
+
+        REQUIRE(!seen.empty());
+        // Exactly once: no duplicates whatever the configuration.
+        for(std::size_t i = 1; i < seen.size(); i++)
+        {
+          CAPTURE(i, seen[i - 1], seen[i]);
+          REQUIRE(seen[i] > seen[i - 1]);
+        }
+        if(strict_f)
+        {
+          // Forward covers [0; total_span[ : every grid point strictly below
+          // the end, exactly once, in order.
+          std::vector<int64_t> expected_f;
+          for(auto p : grid)
+            if(p < total_span)
+              expected_f.push_back(p);
+
+          REQUIRE(seen.size() == expected_f.size());
+          for(std::size_t i = 0; i < seen.size(); i++)
+          {
+            CAPTURE(i, seen[i], expected_f[i]);
+            REQUIRE(matches(seen[i], expected_f[i]));
+          }
+        }
+
+        // ---- Backward over the same ground: exactly once, decreasing.
+        ms.s.interval->set_speed(-1.);
+        std::vector<int64_t> seen_b;
+        for(int i = 0; i < n_ticks + 2; i++)
+        {
+          for(const auto& tk : ms.do_tick(tick_size))
+          {
+            if(tk.date == tk.prev_date)
+              continue;
+            if(!(tk.date < tk.prev_date))
+              continue;
+            for(const auto& q : tk.get_quantification_dates(rate))
+            {
+              CAPTURE(i, tk.prev_date.impl, tk.date.impl, q.date.impl, q.index);
+
+              // Backward interval is ]date; prev].
+              REQUIRE(q.date <= tk.prev_date);
+              REQUIRE(q.date > tk.date);
+
+              const auto p = tk.to_physical_time_in_tick(q.date, flicks_ratio_48k);
+              REQUIRE(p >= tk.physical_start(flicks_ratio_48k));
+              REQUIRE(
+                  p <= tk.physical_start(flicks_ratio_48k)
+                           + tk.physical_write_duration(flicks_ratio_48k));
+
+              seen_b.push_back(q.date.impl);
+            }
+          }
+        }
+
+        REQUIRE(!seen_b.empty());
+        // Exactly once: no duplicates whatever the configuration.
+        for(std::size_t i = 1; i < seen_b.size(); i++)
+        {
+          CAPTURE(i, seen_b[i - 1], seen_b[i]);
+          REQUIRE(seen_b[i] < seen_b[i - 1]);
+        }
+        if(strict_b)
+        {
+          // Rewinding covers ]0; total_span] : every grid point above zero
+          // and up to (and including) the topmost position, exactly once,
+          // decreasing. The point at 0 is not reported: the transport clamps
+          // there and the tick that would cross it ends exactly on it.
+          std::vector<int64_t> expected_b;
+          for(auto it = grid.rbegin(); it != grid.rend(); ++it)
+            if(*it > 0 && *it <= total_span)
+              expected_b.push_back(*it);
+
+          REQUIRE(seen_b.size() == expected_b.size());
+          for(std::size_t i = 0; i < seen_b.size(); i++)
+          {
+            CAPTURE(i, seen_b[i], expected_b[i]);
+            REQUIRE(matches(seen_b[i], expected_b[i]));
+          }
+        }
+      }
+}
+
+TEST_CASE("sweep_metronome_exactly_once", "sweep_metronome_exactly_once")
+{
+  // Over a long forward run followed by the mirror backward run, every bar
+  // and every quarter is clicked exactly once per pass, always inside the
+  // tick's samples.
+  //
+  // The strict exactly-once property only holds while a tick is shorter than
+  // one quarter: metronome() fires at most once per tick by construction, so
+  // with larger ticks (or ticks landing exactly on the grid, where a point at
+  // the shared boundary is attributed to the earlier tick) clicks are
+  // dropped. Ticks of one quarter or more get the weaker at-most-once check.
+  const ossia::time_signature sigs[] = {{4, 4}, {7, 8}, {5, 4}};
+  const double quarter = 1000.;
+
+  for(auto sig : sigs)
+    for(int64_t tick_size : {313, 999, 1000, 1024, 2500})
+    {
+      CAPTURE(sig.upper, sig.lower, tick_size);
+      musical_setup ms(sig, quarter);
+
+      // The strict exactly-once check requires every tick to contain at most
+      // one grid point: the smallest gap between two points is a quarter,
+      // except in signatures with a fractional number of quarters per bar
+      // (7/8: the bar line comes half a quarter after the third beat).
+      const double quarters_per_bar_d = 4. * sig.upper / sig.lower;
+      const double frac_gap = quarters_per_bar_d - std::floor(quarters_per_bar_d);
+      const int64_t min_gap
+          = int64_t((frac_gap > 0. ? frac_gap : 1.) * quarter);
+      const bool strict = tick_size < min_gap;
+
+      int bars_f = 0, quarters_f = 0;
+      const int n_ticks = int(64000 / tick_size) + 1;
+      for(int i = 0; i < n_ticks; i++)
+      {
+        for(const auto& tk : ms.do_tick(tick_size))
+        {
+          if(tk.date == tk.prev_date)
+            continue;
+          const auto wdur = tk.physical_write_duration(flicks_ratio_48k);
+          int fired_this_tick = 0;
+          tk.metronome(
+              flicks_ratio_48k,
+              [&](int64_t s) {
+            bars_f++;
+            fired_this_tick++;
+            CAPTURE(i, s, wdur);
+            REQUIRE(s >= 0);
+            // A tick covering no whole sample still fires, at offset 0.
+            REQUIRE(s <= std::max<int64_t>(0, wdur - 1));
+              },
+              [&](int64_t s) {
+            quarters_f++;
+            fired_this_tick++;
+            CAPTURE(i, s, wdur);
+            REQUIRE(s >= 0);
+            // A tick covering no whole sample still fires, at offset 0.
+            REQUIRE(s <= std::max<int64_t>(0, wdur - 1));
+              });
+          // A tick shorter than the gap between two grid points can only
+          // reach one of them; a longer one reports each it crosses.
+          if(strict)
+            REQUIRE(fired_this_tick <= 1);
+        }
+      }
+
+      // The reference grid: a bar click at each bar start, a quarter click at
+      // each whole quarter within the bar (1, 2, 3 in 4/4 or 7/8; 1..4 in
+      // 5/4: the quarter grid restarts at each bar line).
+      const double quarters_per_bar = 4. * sig.upper / sig.lower;
+      const int64_t bar_model = int64_t(quarters_per_bar * quarter);
+      const int64_t total_span = int64_t(n_ticks) * tick_size;
+      int expected_bars = 0, expected_quarters = 0;
+      for(int64_t b = 0; b < total_span; b += bar_model)
+      {
+        expected_bars++;
+        for(int64_t p = b + int64_t(quarter); p < b + bar_model && p < total_span;
+            p += int64_t(quarter))
+          expected_quarters++;
+      }
+
+      CAPTURE(bars_f, quarters_f, expected_bars, expected_quarters);
+      // Every bar crossed exactly once (incl. the initial downbeat), every
+      // quarter exactly once, whether or not a single tick covers more than one
+      // of them.
+      REQUIRE(bars_f == expected_bars);
+      REQUIRE(quarters_f == expected_quarters);
+
+      // ---- Backward: same clicks while rewinding over the same ground.
+      ms.s.interval->set_speed(-1.);
+      int bars_b = 0, quarters_b = 0;
+      for(int i = 0; i < n_ticks + 2; i++)
+      {
+        for(const auto& tk : ms.do_tick(tick_size))
+        {
+          if(!(tk.date < tk.prev_date))
+            continue;
+          const auto wdur = tk.physical_write_duration(flicks_ratio_48k);
+          int fired_this_tick = 0;
+          tk.metronome(
+              flicks_ratio_48k,
+              [&](int64_t s) {
+            bars_b++;
+            fired_this_tick++;
+            CAPTURE(i, s, wdur);
+            REQUIRE(s >= 0);
+            // A tick covering no whole sample still fires, at offset 0.
+            REQUIRE(s <= std::max<int64_t>(0, wdur - 1));
+              },
+              [&](int64_t s) {
+            quarters_b++;
+            fired_this_tick++;
+            CAPTURE(i, s, wdur);
+            REQUIRE(s >= 0);
+            // A tick covering no whole sample still fires, at offset 0.
+            REQUIRE(s <= std::max<int64_t>(0, wdur - 1));
+              });
+          if(strict)
+            REQUIRE(fired_this_tick <= 1);
+        }
+      }
+
+      CAPTURE(bars_b, quarters_b);
+      if(strict)
+      {
+        // Rewinding does not cross the downbeat at t=0 (the transport clamps
+        // there), so it may see one bar less.
+        REQUIRE(bars_b >= expected_bars - 1);
+        REQUIRE(bars_b <= expected_bars);
+        REQUIRE(std::abs((bars_b + quarters_b) - (bars_f + quarters_f)) <= 1);
+      }
+      else
+      {
+        REQUIRE(bars_b <= expected_bars + 1);
+        REQUIRE(bars_b + quarters_b <= expected_bars + expected_quarters + 1);
+      }
+    }
+}
+
+//------------------------------------------------------------------------------
+// 5. time_value arithmetic around infinity.
+//------------------------------------------------------------------------------
+
+TEST_CASE("time_value_infinity_arithmetic", "time_value_infinity_arithmetic")
+{
+  const ossia::time_value inf{ossia::time_value::infinity};
+  const ossia::time_value big{ossia::time_value::infinite_min};
+  const ossia::time_value x{1000};
+
+  REQUIRE(inf.infinite());
+  REQUIRE(big.infinite());
+
+  // Infinity is absorbing for time_value +/-.
+  REQUIRE((inf + x).infinite());
+  REQUIRE((x + inf).infinite());
+  REQUIRE((inf - x).infinite());
+  REQUIRE((x - inf).infinite());
+  REQUIRE((-inf).infinite());
+
+  // Overflow-avoidance: two huge finite values saturate instead of wrapping.
+  const ossia::time_value half{ossia::time_value::infinite_min - 10};
+  REQUIRE((half + half).infinite());
+  REQUIRE((half + half).impl > 0);
+  REQUIRE((-half - half).infinite()); // saturates, does not wrap to negative
+
+  // Subtraction of a large negative saturates too.
+  const ossia::time_value neg{-(ossia::time_value::infinite_min - 10)};
+  REQUIRE((half - neg).infinite());
+
+  // The ordering operators agree with ==: if two values are equal they are
+  // also <= and >= each other, and neither is strictly less or greater.
+  REQUIRE(inf == big);
+  REQUIRE(inf <= big);
+  REQUIRE(inf >= big);
+  REQUIRE(!(inf < big));
+  REQUIRE(!(inf > big));
+  REQUIRE(inf <= inf);
+  REQUIRE(inf >= inf);
+
+  // += saturates the way + does, rather than collapsing to zero.
+  {
+    ossia::time_value acc = inf;
+    acc += int64_t(5);
+    REQUIRE(acc.infinite());
+
+    ossia::time_value acc2 = inf;
+    acc2 += x;
+    REQUIRE(acc2.infinite());
+
+    ossia::time_value acc3{1000};
+    acc3 += int64_t(234);
+    REQUIRE(acc3.impl == 1234);
+  }
+
+  // Scaling an infinite duration keeps it infinite.
+  REQUIRE((inf * 2.).infinite());
+  REQUIRE((inf * 0.5).infinite());
+  REQUIRE((inf * int64_t(3)).infinite());
+  REQUIRE((x * 2.).impl == 2000);
+
+  // Finite arithmetic is exact.
+  REQUIRE((x + ossia::time_value{234}).impl == 1234);
+  REQUIRE((x - ossia::time_value{234}).impl == 766);
+  REQUIRE((x - ossia::time_value{2000}).impl == -1000);
+}
+
+//------------------------------------------------------------------------------
+// 6. Zero-length and sub-buffer intervals inside a scenario, both directions.
+//------------------------------------------------------------------------------
+
+TEST_CASE("scenario_zero_length_interval_in_chain", "scenario_zero_length_interval_in_chain")
+{
+  const int bs = 64;
+  ossia::execution_state e;
+  setup_state(e, bs);
+  const int64_t buffer_flicks = int64_t(bs / flicks_ratio_48k);
+
+  root_scenario s;
+  auto se = start_event(*s.scenario);
+  auto e1 = create_event(*s.scenario);
+  auto e2 = create_event(*s.scenario);
+  auto e3 = create_event(*s.scenario);
+
+  auto c0 = create_interval(*se, *e1, ossia::time_value{buffer_flicks / 2});
+  auto c1 = create_interval(*e1, *e2, ossia::time_value{0}); // zero-length
+  auto c2 = create_interval(*e2, *e3, ossia::time_value{8 * buffer_flicks});
+  s.scenario->add_time_interval(c0);
+  s.scenario->add_time_interval(c1);
+  s.scenario->add_time_interval(c2);
+
+  auto p0 = std::make_shared<probe_node>();
+  auto p2 = std::make_shared<probe_node>();
+  c0->add_time_process(std::make_shared<ossia::node_process>(p0));
+  c2->add_time_process(std::make_shared<ossia::node_process>(p2));
+
+  s.interval->start();
+  s.interval->tick_current(ossia::time_value{}, {});
+
+  auto do_tick = [&] {
+    std::vector<probe_node::span> all;
+    for(auto& p : {p0, p2})
+    {
+      p->requested_tokens.clear();
+      p->spans.clear();
+    }
+    s.interval->tick(ossia::time_value{buffer_flicks}, root_request(bs));
+    for(auto& p : {p0, p2})
+    {
+      for(auto& tk : p->requested_tokens)
+        p->run(tk, {&e});
+      all.insert(all.end(), p->spans.begin(), p->spans.end());
+    }
+    return all;
+  };
+
+  // Forward across the zero-length interval: the buffer is still tiled by the
+  // intervals that have any extent.
+  {
+    const auto all = do_tick();
+    require_exact_coverage(all, bs);
+    REQUIRE(!p2->spans.empty()); // we crossed into c2
+    REQUIRE(p2->spans[0].start == bs / 2);
+  }
+  require_exact_coverage(do_tick(), bs);
+
+  // And back down over it.
+  s.interval->set_speed(-1.);
+  require_exact_coverage(do_tick(), bs);
+
+  // KNOWN BUG: the next backward tick would have to cross the zero-length
+  // interval (started at date 0 by the cascade) and re-enter c0; the
+  // early-return in run_interval_backward for intervals already at date 0
+  // stalls the cascade instead. Covered by
+  // scenario_backward_stalls_on_exact_boundary below.
+}
+
+TEST_CASE(
+    "scenario_backward_crosses_zero_length_interval",
+    "[scenario_backward_crosses_zero_length_interval]")
+{
+  // KNOWN BUG, same early-return as scenario_backward_stalls_on_exact_boundary:
+  // a zero-length interval is transported to its nominal duration (0) when the
+  // backward cascade starts it, so run_interval_backward refuses to cascade
+  // through it and everything before it never plays while rewinding.
+  const int bs = 64;
+  ossia::execution_state e;
+  setup_state(e, bs);
+  const int64_t buffer_flicks = int64_t(bs / flicks_ratio_48k);
+
+  root_scenario s;
+  auto se = start_event(*s.scenario);
+  auto e1 = create_event(*s.scenario);
+  auto e2 = create_event(*s.scenario);
+  auto e3 = create_event(*s.scenario);
+
+  auto c0 = create_interval(*se, *e1, ossia::time_value{buffer_flicks / 2});
+  auto c1 = create_interval(*e1, *e2, ossia::time_value{0}); // zero-length
+  auto c2 = create_interval(*e2, *e3, ossia::time_value{8 * buffer_flicks});
+  s.scenario->add_time_interval(c0);
+  s.scenario->add_time_interval(c1);
+  s.scenario->add_time_interval(c2);
+
+  auto p0 = std::make_shared<probe_node>();
+  auto p2 = std::make_shared<probe_node>();
+  c0->add_time_process(std::make_shared<ossia::node_process>(p0));
+  c2->add_time_process(std::make_shared<ossia::node_process>(p2));
+
+  s.interval->start();
+  s.interval->tick_current(ossia::time_value{}, {});
+
+  auto do_tick = [&] {
+    std::vector<probe_node::span> all;
+    for(auto& p : {p0, p2})
+    {
+      p->requested_tokens.clear();
+      p->spans.clear();
+    }
+    s.interval->tick(ossia::time_value{buffer_flicks}, root_request(bs));
+    for(auto& p : {p0, p2})
+    {
+      for(auto& tk : p->requested_tokens)
+        p->run(tk, {&e});
+      all.insert(all.end(), p->spans.begin(), p->spans.end());
+    }
+    return all;
+  };
+
+  require_exact_coverage(do_tick(), bs); // forward across c1: fine
+  require_exact_coverage(do_tick(), bs);
+  s.interval->set_speed(-1.);
+  require_exact_coverage(do_tick(), bs); // still inside c2: fine
+
+  // Crossing back over the zero-length interval: c0 must get the second half
+  // of the buffer.
+  const auto all = do_tick();
+  require_exact_coverage(all, bs);
+  REQUIRE(!p0->spans.empty());
+}
diff --git a/tests/Editor/QuantificationTest.cpp b/tests/Editor/QuantificationTest.cpp
index 74c0896eb52..4fbacc36d4c 100644
--- a/tests/Editor/QuantificationTest.cpp
+++ b/tests/Editor/QuantificationTest.cpp
@@ -6,6 +6,7 @@
 
 #include <ossia/editor/scenario/time_interval.hpp>
 
+#include <map>
 #include <utility>
 using namespace ossia;
 using namespace std::placeholders;
@@ -270,3 +271,83 @@ TEST_CASE("test_quant", "test_quant")
 
   //
 }
+
+// Every musical grid point must be reported by exactly one tick: the tick
+// owns [prev_date; date[ and the next one starts where it ended. A grid point
+// sitting musically on the very end of a tick used to fire twice - once at
+// the tick's last flick, because truncating its date to a whole flick pulled
+// it inside, and once more at the next tick's first flick. A quantized
+// trigger or a step sequencer then executed the same point twice, one sample
+// apart. This sweep reproduces the exact tick streams that exposed it.
+TEST_CASE("quantification_points_fire_exactly_once", "[quantification]")
+{
+  constexpr double Q = 352800000.0; // flicks per quarter through model time
+  constexpr double FPS48 = 705600000.0 / 48000.0;
+
+  for(double rate : {1., 1.5, 2., 3., 4., 8.})
+  {
+    for(double speed : {1.0, 0.5, 1.37, 2.0})
+    {
+      for(int L : {128, 512})
+      {
+        // Count the reported points per musical position, over a long run of
+        // consecutive ticks advanced with floor + carried residue like
+        // time_interval::take_step.
+        std::map<long long, int> seen;
+        double residue = 0.;
+        int64_t d = 0;
+        double last_end = 0.;
+        for(int t = 0; t < 6000; t++)
+        {
+          const double exact = L * FPS48 * speed + residue;
+          const double step = std::floor(exact);
+          residue = exact - step;
+          const int64_t nd = d + int64_t(step);
+
+          ossia::token_request tok;
+          tok.prev_date = ossia::time_value{d};
+          tok.date = ossia::time_value{nd};
+          tok.speed = 1.;
+          tok.tempo = 120.;
+          tok.signature = ossia::time_signature{4, 4};
+          tok.start_sample = 0;
+          tok.length_sample = L;
+          tok.musical_start_last_signature = 0.;
+          tok.musical_start_position = d / Q;
+          tok.musical_start_last_bar
+              = std::floor(tok.musical_start_position / 4.) * 4.;
+          tok.musical_end_position = nd / Q;
+          tok.musical_end_last_bar = std::floor(tok.musical_end_position / 4.) * 4.;
+
+          for(const auto& p : tok.get_quantification_dates(rate))
+          {
+            // Key each point by its musical position on an eighth-of-a-quarter
+            // lattice: reporting noise is < 1e-6 quarters, distinct points of
+            // these rates are >= 1/3 quarter apart.
+            const double frac = double(p.date.impl - d) / double(nd - d);
+            const double mus = tok.musical_start_position
+                               + frac
+                                     * (tok.musical_end_position
+                                        - tok.musical_start_position);
+            seen[llround(mus * 8.)]++;
+          }
+          last_end = nd / Q;
+          d = nd;
+        }
+
+        for(const auto& [key, count] : seen)
+        {
+          // Ignore the last partial bar: those points may legitimately still
+          // be waiting for the tick that owns them.
+          if(key / 8. < last_end - 4.)
+          {
+            INFO(
+                "rate " << rate << " speed " << speed << " L " << L << " point "
+                        << key / 8. << " fired " << count << " times");
+            REQUIRE(count == 1);
+          }
+        }
+      }
+    }
+  }
+}