@mthines/reaper-mcp 0.19.0 → 0.70.2

package/sidecar/tests/test_analysis.py

@@ -0,0 +1,249 @@
+"""
+Tests for sidecar/analysis.py against the EBU loudness reference signals.
+
+Run with the sidecar venv (numpy, torch, soundfile):
+    ~/.reaper-mcp/sidecar-venv/bin/python -m pytest apps/reaper-mcp-server/sidecar/tests -q
+"""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+import numpy as np
+
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+import analysis  # noqa: E402
+
+SR = 48000
+
+
+def sine(freq: float, dbfs: float, seconds: float, channels: int = 2, sr: int = SR) -> np.ndarray:
+    t = np.arange(int(seconds * sr)) / sr
+    wave = (10 ** (dbfs / 20) * np.sin(2 * np.pi * freq * t)).astype(np.float32)
+    return np.tile(wave, (channels, 1))
+
+
+def test_integrated_loudness_ebu3341_sine():
+    # EBU Tech 3341 case 1: stereo 1 kHz sine at -23 dBFS reads -23 LUFS
+    lufs = analysis.integrated_loudness(sine(1000, -23, 20), SR)
+    assert abs(lufs - (-23.0)) <= 0.3
+
+
+def test_integrated_loudness_other_sample_rate():
+    lufs = analysis.integrated_loudness(sine(1000, -23, 10, sr=44100), 44100)
+    assert abs(lufs - (-23.0)) <= 0.3
+
+
+def test_integrated_loudness_silence_is_minus_inf():
+    assert analysis.integrated_loudness(np.zeros((2, SR * 2), dtype=np.float32), SR) == float("-inf")
+
+
+def test_loudness_range_ebu3342_two_levels():
+    # EBU Tech 3342 case 1: 20 s at -20 dBFS then 20 s at -30 dBFS → LRA 10 LU
+    audio = np.concatenate([sine(1000, -20, 20), sine(1000, -30, 20)], axis=1)
+    lra = analysis.loudness_range(audio, SR)
+    assert lra is not None and abs(lra - 10.0) <= 1.0
+
+
+def test_true_peak_exceeds_sample_peak():
+    # fs/4 sine at 45° phase: every sample sits at 0.707 of the real peak
+    n = np.arange(SR)
+    wave = np.sin(np.pi / 2 * n + np.pi / 4).astype(np.float32) * 0.5
+    audio = np.tile(wave, (2, 1))
+    sample_peak = float(np.abs(audio).max())
+    tp = analysis.true_peak(audio, SR)
+    assert tp > sample_peak * 1.2
+
+
+def test_reference_treble_delta_positive_when_brighter():
+    rng = np.random.default_rng(1)
+    noise = rng.standard_normal((2, SR * 6)).astype(np.float32) * 0.05
+    # The "mix" adds strong high-frequency content on top of the same noise
+    brighter = noise + sine(9000, -12, 6)
+    result = analysis.compare_to_reference(brighter, SR, noise, SR)
+    # Band figures are shares of total energy, so more treble means less of the rest
+    assert result["bandDeltaDb"]["brilliance"] > 0.5
+    assert result["bandDeltaDb"]["bass"] < 0
+    assert result["loudnessDeltaLu"] > 0
+    top = result["largestDifferences"][0]
+    assert 8000 <= top["hz"] <= 11000 and top["deltaDb"] > 6
+
+
+def test_alignment_detects_delay_and_inverted_polarity():
+    rng = np.random.default_rng(7)
+    ref = rng.standard_normal((1, SR)).astype(np.float32)
+    delayed = np.zeros_like(ref)
+    delayed[:, 37:] = -ref[:, :-37]
+    result = analysis.alignment(ref, delayed, SR, max_lag_ms=5)
+    assert result["delaySamples"] == 37
+    assert result["polarityInverted"] is True
+    assert result["correlation"] > 0.9
+
+
+def test_alignment_reports_negative_lag_when_target_is_early():
+    rng = np.random.default_rng(3)
+    ref = rng.standard_normal((2, SR)).astype(np.float32)
+    early = np.zeros_like(ref)
+    early[:, :-12] = ref[:, 12:]
+    result = analysis.alignment(ref, early, SR, max_lag_ms=5)
+    assert result["delaySamples"] == -12
+    assert result["polarityInverted"] is False
+
+
+def test_normalize_to_lufs_hits_target():
+    audio = sine(1000, -30, 5)
+    out, measured, gain = analysis.normalize_to_lufs(audio, SR, -18.0)
+    assert abs(measured - (-30.0)) <= 0.3
+    assert abs(gain - 12.0) <= 0.3
+    assert abs(analysis.integrated_loudness(out, SR) - (-18.0)) <= 0.1
+
+
+def test_normalize_leaves_silence_alone():
+    silent = np.zeros((2, SR), dtype=np.float32)
+    out, measured, gain = analysis.normalize_to_lufs(silent, SR, -18.0)
+    assert measured is None and gain == 0.0 and out is silent
+
+
+def test_analyze_reports_sections_and_resonance():
+    rng = np.random.default_rng(5)
+    audio = rng.standard_normal((2, SR * 8)).astype(np.float32) * 0.05 + sine(3150, -14, 8)
+    result = analysis.analyze(audio, SR, section_s=4)
+    assert len(result["loudness"]["sections"]) == 2
+    hzs = [r["hz"] for r in result["spectrum"]["resonances"]]
+    assert any(abs(h - 3150) < 40 for h in hzs)
+
+
+def test_alignment_names_the_silent_signal():
+    ref = sine(1000, -20, 1, channels=1)
+    result = analysis.alignment(ref, np.zeros_like(ref), SR)
+    assert result["delaySamples"] is None
+    assert result["error"].startswith("The track is silent")
+
+
+def test_sibilance_on_silence_has_the_same_keys():
+    power, freqs = analysis._stft_power(np.zeros((2, SR * 2), dtype=np.float32), SR)
+    assert analysis.sibilance_hint(power, freqs, 2048 / SR)["spikeCount"] == 0
+
+
+def test_sibilance_reports_each_burst_once():
+    rng = np.random.default_rng(2)
+    audio = sine(200, -20, 6)
+    for start in (1.0, 3.0):  # two 0.3 s hiss bursts
+        i = int(start * SR)
+        audio[:, i:i + int(0.3 * SR)] += rng.standard_normal((2, int(0.3 * SR))).astype(np.float32) * 0.3
+    power, freqs = analysis._stft_power(audio, SR)
+    hint = analysis.sibilance_hint(power, freqs, 2048 / SR)
+    assert hint["spikeCount"] == 2
+    assert [round(t) for t in hint["spikeSeconds"]] == [1, 3]
+
+
+def test_chunked_k_weighting_and_true_peak_match_one_piece(monkeypatch):
+    rng = np.random.default_rng(11)
+    audio = (rng.standard_normal((2, SR * 7)) * 0.1).astype(np.float32)
+    whole_kw = analysis.k_weight(audio, SR)
+    whole_tp = analysis.true_peak(audio, SR)
+    monkeypatch.setattr(analysis, "CHUNK_S", 2.0)  # 4 chunks, the last one short
+    assert np.max(np.abs(analysis.k_weight(audio, SR) - whole_kw)) < 1e-9
+    assert abs(analysis.true_peak(audio, SR) - whole_tp) < 1e-3
+
+
+def drum_loop(seconds: float = 8.0, sr: int = SR) -> tuple[np.ndarray, list[float], list[float]]:
+    """A 60 Hz kick on every beat at 120 BPM and a hi-hat (high-passed noise) on every off-beat."""
+    rng = np.random.default_rng(0)
+    x = rng.normal(0, 0.002, int(seconds * sr)).astype(np.float32)
+    kicks, hats = [], []
+    for k in range(int((seconds - 0.5) / 0.5)):
+        s = int((0.25 + 0.5 * k) * sr)
+        t = np.arange(int(0.2 * sr)) / sr
+        x[s:s + t.size] += (0.8 * np.sin(2 * np.pi * 60 * t) * np.exp(-t * 25)).astype(np.float32)
+        h = s + int(0.25 * sr)
+        n = int(0.03 * sr)
+        hat = np.diff(rng.normal(0, 1, n + 3), 3) / 8  # third difference: energy above ~5 kHz
+        x[h:h + n] += (0.3 * hat * np.exp(-np.arange(n) / sr * 150)).astype(np.float32)
+        kicks.append(s / sr)
+        hats.append(h / sr)
+    return np.vstack([x, x]), kicks, hats
+
+
+def test_transients_finds_kicks_and_hats_with_their_bands_and_tempo():
+    audio, kicks, hats = drum_loop()
+    result = analysis.transients(audio, SR)
+
+    found = result["transients"]
+    assert result["count"] == len(kicks) + len(hats)
+    for expected, band in [*((t, "low") for t in kicks), *((t, "high") for t in hats)]:
+        nearest = min(found, key=lambda f: abs(f["time"] - expected))
+        assert abs(nearest["time"] - expected) < 0.005
+        assert nearest["band"] == band
+        assert 0 < nearest["strength"] <= 1
+    assert abs(result["tempo"]["bpm"] - 120) < 1
+
+
+def test_transients_in_one_band_skip_the_other_instruments():
+    audio, kicks, _ = drum_loop()
+    low = analysis.transients(audio, SR, band="low")
+    assert low["count"] == len(kicks)
+
+
+def test_transients_lower_sensitivity_never_finds_more():
+    audio, _, _ = drum_loop()
+    loose = analysis.transients(audio, SR, sensitivity=0.9)["count"]
+    strict = analysis.transients(audio, SR, sensitivity=0.1)["count"]
+    assert strict <= loose
+
+
+def test_transients_of_silence_is_empty():
+    result = analysis.transients(np.zeros((2, SR * 2), dtype=np.float32), SR)
+    assert result["count"] == 0
+    assert result["tempo"]["bpm"] is None
+
+
+def _tones(freqs_hz, seconds=3.0, sr=44100):
+    t = np.arange(int(seconds * sr)) / sr
+    return np.stack([sum(np.sin(2 * np.pi * f * t) for f in freqs_hz) / len(freqs_hz)] * 2).astype(np.float32), sr
+
+
+def test_chroma_of_a_c_major_triad_peaks_on_c_e_g():
+    # C4, E4, G4
+    audio, sr = _tones([261.63, 329.63, 392.00])
+    result = analysis.chroma(audio, sr)
+    c = result["chroma"]
+    assert len(c) == 12
+    strongest = sorted(range(12), key=lambda i: -c[i])[:3]
+    assert sorted(strongest) == [0, 4, 7]
+    assert max(c) == 1.0
+    assert all(c[i] < 0.5 for i in range(12) if i not in (0, 4, 7))
+
+
+def test_chroma_puts_no_weight_on_the_wrong_class_for_a_low_bass_note():
+    # A1 and B1 with their first harmonics: down there a bin is wider than a semitone, so the
+    # fundamental must not add weight to the neighbouring classes (B flat, C)
+    c = analysis.chroma(*_tones([55.0, 110.0, 165.0]))["chroma"]
+    assert c[10] < 0.3
+    c = analysis.chroma(*_tones([61.74, 123.47, 185.2]))["chroma"]
+    assert c[10] < 0.5 and c[0] < 0.5
+    # B minor (B3, D4, F#4) over a B1 bass with its octave: the triad's classes stay on top
+    c = analysis.chroma(*_tones([61.74, 123.47, 246.94, 293.66, 369.99]))["chroma"]
+    assert sorted(sorted(range(12), key=lambda i: -c[i])[:3]) == [2, 6, 11]
+
+
+def test_chroma_skips_silence_and_returns_zeros_for_it():
+    audio = np.zeros((2, 44100 * 2), dtype=np.float32)
+    result = analysis.chroma(audio, 44100)
+    assert result["chroma"] == [0.0] * 12
+    assert result["frames"] == 0
+
+
+def test_chroma_per_segment_follows_a_chord_change_and_zeros_a_silent_segment():
+    # Two seconds of C major (C E G), two of A minor (A C E), then a second of silence
+    c_major, sr = _tones([261.63, 329.63, 392.00], seconds=2.0)
+    a_minor, _ = _tones([220.0, 261.63, 329.63], seconds=2.0)
+    audio = np.concatenate([c_major, a_minor, np.zeros((2, sr), dtype=np.float32)], axis=1)
+    result = analysis.chroma(audio, sr, segments=[[0.2, 1.8], [2.2, 3.8], [4.2, 4.9]])
+    first, second, silent = result["segments"]
+    assert sorted(sorted(range(12), key=lambda i: -first[i])[:3]) == [0, 4, 7]
+    assert sorted(sorted(range(12), key=lambda i: -second[i])[:3]) == [0, 4, 9]
+    assert silent == [0.0] * 12
+    assert len(result["chroma"]) == 12

package/sidecar/tests/test_chords.py

@@ -0,0 +1,117 @@
+"""
+Tests for sidecar/chords.py and the server's chords methods, with a fake lv_chordia
+(the real model is not installed in CI).
+
+Run with the sidecar venv:
+    ~/.reaper-mcp/sidecar-venv/bin/python -m pytest apps/reaper-mcp-server/sidecar/tests/test_chords.py -q
+"""
+
+from __future__ import annotations
+
+import json
+import sys
+import types
+from pathlib import Path
+
+import numpy as np
+import pytest
+
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+import chords  # noqa: E402
+import server  # noqa: E402
+
+SR = 22050
+
+
+@pytest.fixture
+def wav(tmp_path):
+    import soundfile as sf
+
+    path = tmp_path / "song.wav"
+    t = np.arange(SR * 8) / SR
+    sf.write(path, (0.2 * np.sin(2 * np.pi * 220 * t)).astype(np.float32), SR)
+    return str(path)
+
+
+@pytest.fixture
+def fake_model(monkeypatch):
+    """A fake lv_chordia that labels every 2 s of whatever file it gets, and records the call."""
+    calls = []
+
+    def chord_recognition(audio_path, chord_dict_name="submission"):
+        import soundfile as sf
+
+        seconds = sf.info(audio_path).duration
+        calls.append({"path": audio_path, "vocab": chord_dict_name, "seconds": round(seconds, 2)})
+        labels = ["A:min", "F:maj", "C:maj/3", "N"]
+        out, t, i = [], 0.0, 0
+        while t < seconds - 1e-6:
+            out.append({"start_time": t, "end_time": min(t + 2, seconds), "chord": labels[i % 4]})
+            t, i = t + 2, i + 1
+        return out
+
+    package = types.ModuleType("lv_chordia")
+    module = types.ModuleType("lv_chordia.chord_recognition")
+    module.chord_recognition = chord_recognition
+    package.chord_recognition = module
+    monkeypatch.setitem(sys.modules, "lv_chordia", package)
+    monkeypatch.setitem(sys.modules, "lv_chordia.chord_recognition", module)
+    monkeypatch.setattr(chords, "is_installed", lambda: True)
+    return calls
+
+
+def call(method, **params):
+    return json.loads(server.dispatch(json.dumps({"jsonrpc": "2.0", "id": 1, "method": method, "params": params})))
+
+
+def test_returns_the_models_segments_in_file_seconds(wav, fake_model):
+    result = call("chords", path=wav)["result"]
+    assert [s["label"] for s in result["segments"]] == ["A:min", "F:maj", "C:maj/3", "N"]
+    assert result["segments"][1] == {"start": 2.0, "end": 4.0, "label": "F:maj"}
+    assert result["durationSeconds"] == pytest.approx(8.0)
+    assert fake_model[0]["vocab"] == "submission"
+
+
+def test_a_range_is_cut_out_and_its_times_stay_in_file_seconds(wav, fake_model):
+    result = call("chords", path=wav, startTime=3, endTime=7, vocabulary="ismir2017")["result"]
+    assert fake_model[0]["seconds"] == pytest.approx(4.0)
+    assert fake_model[0]["path"] != wav
+    assert not Path(fake_model[0]["path"]).exists()
+    assert result["segments"][0]["start"] == pytest.approx(3.0)
+    assert result["segments"][-1]["end"] == pytest.approx(7.0)
+    assert result["vocabulary"] == "ismir2017"
+
+
+def test_refuses_an_unknown_vocabulary_and_a_missing_file(wav, fake_model):
+    assert call("chords", path=wav, vocabulary="jazz")["error"]["code"] == -32602
+    assert "not found" in call("chords", path="/nope/missing.wav")["error"]["message"]
+    assert fake_model == []
+
+
+def test_without_the_model_says_how_to_install_it(wav, monkeypatch):
+    monkeypatch.setattr(chords, "is_installed", lambda: False)
+    error = call("chords", path=wav)["error"]
+    assert "--with-chords" in error["message"]
+    status = call("chords_status")["result"]
+    assert status["installed"] is False and "--with-chords" in status["message"]
+
+
+def test_a_model_that_fails_to_load_is_not_installed_and_says_why(wav, monkeypatch):
+    # lv-chordia present but one of its imports missing (pydub's audioop on Python 3.13)
+    package = types.ModuleType("lv_chordia")
+    monkeypatch.setitem(sys.modules, "lv_chordia", package)
+    monkeypatch.setitem(sys.modules, "lv_chordia.chord_recognition", None)
+    status = call("chords_status")["result"]
+    assert status["installed"] is False
+    assert "does not load" in status["message"] and "--with-chords" in status["message"]
+    assert "does not load" in call("chords", path=wav)["error"]["message"]
+
+
+def test_a_model_that_loads_is_installed(monkeypatch):
+    package = types.ModuleType("lv_chordia")
+    module = types.ModuleType("lv_chordia.chord_recognition")
+    package.chord_recognition = module
+    monkeypatch.setitem(sys.modules, "lv_chordia", package)
+    monkeypatch.setitem(sys.modules, "lv_chordia.chord_recognition", module)
+    assert call("chords_status")["result"]["installed"] is True

package/sidecar/tests/test_mixcheck.py

@@ -0,0 +1,163 @@
+"""
+Tests for sidecar/mixcheck.py: loudness curve, per-band stereo correlation, masking.
+
+Run with the sidecar venv (numpy, torch, soundfile):
+    ~/.reaper-mcp/sidecar-venv/bin/python -m pytest apps/reaper-mcp-server/sidecar/tests -q
+"""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+import numpy as np
+import pytest
+
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+import mixcheck  # noqa: E402
+
+SR = 48000
+
+
+def tone(freq: float, dbfs: float, seconds: float, sr: int = SR) -> np.ndarray:
+    t = np.arange(int(seconds * sr)) / sr
+    return (10 ** (dbfs / 20) * np.sin(2 * np.pi * freq * t)).astype(np.float32)
+
+
+def stereo(left: np.ndarray, right: np.ndarray) -> np.ndarray:
+    return np.stack([left, right])
+
+
+def noise(seconds: float, seed: int, sr: int = SR) -> np.ndarray:
+    return (np.random.default_rng(seed).standard_normal(int(seconds * sr)) * 0.1).astype(np.float32)
+
+
+# --- loudness curve ---------------------------------------------------------
+
+def test_curve_follows_a_quiet_then_loud_song_and_finds_the_loud_part():
+    quiet, loud = tone(1000, -33, 10), tone(1000, -13, 10)
+    audio = stereo(np.concatenate([quiet, loud]), np.concatenate([quiet, loud]))
+    r = mixcheck.loudness_curve(audio, SR)
+    st = r["shortTerm"]["lufs"]
+    assert abs(st[0] - (-33)) < 0.5 and abs(st[-1] - (-13)) < 0.5
+    assert r["loudest"]["start"] >= 10 and abs(r["loudest"]["lufs"] - (-13)) < 0.5
+    assert r["quietest"]["start"] < 7
+
+
+def test_curve_never_returns_more_points_than_its_cap_and_keeps_the_peak():
+    audio = stereo(tone(1000, -30, 300), tone(1000, -30, 300))
+    audio[:, 150 * SR:151 * SR] *= 10  # a 1 s burst 20 dB up
+    r = mixcheck.loudness_curve(audio, SR)
+    assert len(r["shortTerm"]["lufs"]) <= mixcheck.CURVE_POINTS
+    assert len(r["momentary"]["lufs"]) <= mixcheck.CURVE_POINTS
+    assert max(r["momentary"]["lufs"]) > -12, "a bucket keeps its loudest value"
+
+
+def test_curve_reports_the_spans_over_a_target():
+    quiet, loud = tone(1000, -20, 10), tone(1000, -10, 6)
+    audio = stereo(np.concatenate([quiet, loud, quiet]), np.concatenate([quiet, loud, quiet]))
+    r = mixcheck.loudness_curve(audio, SR, target_lufs=-14)
+    assert len(r["overTarget"]) == 1
+    span = r["overTarget"][0]
+    assert 7 <= span["start"] <= 10 and 15 <= span["end"] <= 19
+    assert r["overTargetSeconds"] > 4
+
+
+def test_curve_of_a_clip_shorter_than_3_s_says_only_momentary_is_reported():
+    r = mixcheck.loudness_curve(stereo(tone(1000, -20, 2), tone(1000, -20, 2)), SR)
+    assert "shortTerm" not in r and r["momentary"]["lufs"]
+    assert "momentary" in r["warning"]
+
+
+# --- stereo correlation per band -------------------------------------------
+
+def test_mono_source_correlates_fully_in_every_band():
+    n = noise(5, 1)
+    r = mixcheck.band_correlation(stereo(n, n), SR)
+    assert all(b["correlation"] > 0.99 for b in r["bands"])
+    assert r["flags"] == []
+
+
+def test_out_of_phase_low_end_is_flagged_while_the_highs_stay_mono():
+    low = tone(60, -12, 5)
+    high = tone(4000, -12, 5)
+    r = mixcheck.band_correlation(stereo(low + high, -low + high), SR)
+    by = {b["band"]: b for b in r["bands"]}
+    assert by["low"]["correlation"] < -0.9
+    assert by["high"]["correlation"] > 0.9
+    assert any("low end" in f for f in r["flags"])
+
+
+def test_wide_uncorrelated_mids_read_near_zero_with_side_close_to_mid():
+    r = mixcheck.band_correlation(stereo(noise(5, 1), noise(5, 2)), SR)
+    mid = next(b for b in r["bands"] if b["band"] == "mid")
+    assert abs(mid["correlation"]) < 0.1
+    assert abs(mid["sideToMidDb"]) < 1.5
+    assert len(mid["series"]) <= mixcheck.BAND_SERIES_POINTS
+
+
+def test_band_correlation_refuses_a_mono_file():
+    with pytest.raises(ValueError, match="stereo"):
+        mixcheck.band_correlation(tone(100, -12, 2)[None, :], SR)
+
+
+# --- masking -----------------------------------------------------------------
+
+def test_two_tracks_in_the_same_band_at_the_same_level_conflict_there():
+    bass = stereo(tone(100, -12, 5), tone(100, -12, 5))
+    kick = stereo(tone(100, -13, 5) + tone(3000, -30, 5), tone(100, -13, 5) + tone(3000, -30, 5))
+    r = mixcheck.masking([("Bass", bass), ("Kick", kick)], SR)
+    top = r["conflicts"][0]
+    assert top["hz"] == 100 and top["score"] > 0.8
+    assert {top["a"], top["b"]} == {"Bass", "Kick"}
+    assert "cut" in top["suggestion"]
+    assert len(r["pairs"]) == 1 and len(r["pairs"][0]["scores"]) == len(r["bandsHz"])
+
+
+def test_tracks_in_different_bands_do_not_conflict():
+    low = stereo(tone(80, -12, 5), tone(80, -12, 5))
+    high = stereo(tone(5000, -12, 5), tone(5000, -12, 5))
+    r = mixcheck.masking([("Bass", low), ("Hat", high)], SR)
+    assert r["conflicts"] == []
+
+
+def test_masking_suggests_cutting_the_track_the_band_matters_less_to():
+    # The guitar's energy is mostly at 1 kHz; at 250 Hz it is a minor part of it,
+    # while the 250 Hz tone is the whole of the pad
+    pad = tone(250, -18, 5)
+    guitar = tone(1000, -6, 5) + tone(250, -18, 5)
+    r = mixcheck.masking([("Pad", stereo(pad, pad)), ("Guitar", stereo(guitar, guitar))], SR)
+    at250 = next(c for c in r["conflicts"] if c["hz"] == 250)
+    assert at250["suggestion"].startswith("cut Guitar")
+
+
+def test_masking_needs_two_tracks():
+    with pytest.raises(ValueError):
+        mixcheck.masking([("Solo", stereo(noise(1, 1), noise(1, 1)))], SR)
+
+
+# --- speed ------------------------------------------------------------------
+# Bounds sit ~10× over what these take on a laptop (900 s curve ≈ 1.6 s, stereo ≈ 1.4 s, masking ≈ 0.15 s),
+# so only a real regression (a per-sample loop, a quadratic step) trips them.
+
+
+def test_the_longest_inputs_each_check_accepts_finish_in_seconds():
+    import time
+
+    song = stereo(noise(900, 1), noise(900, 2))
+    t0 = time.perf_counter()
+    curve = mixcheck.loudness_curve(song, SR, -14)
+    curve_s = time.perf_counter() - t0
+    t0 = time.perf_counter()
+    bands = mixcheck.band_correlation(song, SR)
+    bands_s = time.perf_counter() - t0
+    tracks = [(f"T{i}", stereo(noise(60, 10 + i), noise(60, 20 + i))) for i in range(8)]
+    t0 = time.perf_counter()
+    masking = mixcheck.masking(tracks, SR)
+    masking_s = time.perf_counter() - t0
+
+    assert len(curve["shortTerm"]["lufs"]) <= 240
+    assert len(bands["bands"]) == 5
+    assert len(masking["pairs"]) == 28
+    assert curve_s < 20 and bands_s < 20 and masking_s < 5, (curve_s, bands_s, masking_s)

package/sidecar/tests/test_separation.py

@@ -0,0 +1,73 @@
+"""
+Tests for sidecar/separation.py. The Demucs run is skipped unless demucs is installed
+(`reaper-mcp setup-sidecar --with-separation`); it downloads the model on first use.
+"""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+import numpy as np
+import pytest
+
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+import separation  # noqa: E402
+
+
+def _mix(path: Path, sr: int = 44100, seconds: float = 8.0) -> None:
+    import soundfile as sf
+
+    t = np.arange(int(seconds * sr)) / sr
+    bass = 0.3 * np.sin(2 * np.pi * 55 * t)
+    drums = np.zeros_like(t)
+    for k in np.arange(0, seconds, 0.5):
+        i, n = int(k * sr), int(0.08 * sr)
+        drums[i:i + n] += np.random.default_rng(int(k * 10)).standard_normal(min(n, t.size - i)) \
+            * np.exp(-np.arange(min(n, t.size - i)) / (0.015 * sr)) * 0.5
+    x = (bass + drums).astype(np.float32)
+    sf.write(str(path), np.stack([x, x], axis=1), sr)
+
+
+def test_refuses_an_unknown_model_or_stem_without_writing():
+    with pytest.raises(ValueError, match="Unknown model"):
+        separation.separate("/nope.wav", "/tmp/out-never", model_name="spleeter")
+    with pytest.raises(ValueError, match="has no stem guitar"):
+        separation.separate("/nope.wav", "/tmp/out-never", stems=["guitar"])
+
+
+@pytest.mark.skipif(not separation.is_installed(), reason="demucs not installed (setup-sidecar --with-separation)")
+def test_writes_only_the_asked_stems_as_float_wavs_at_the_model_rate(tmp_path):
+    import soundfile as sf
+
+    _mix(tmp_path / "mix.wav")
+    r = separation.separate(str(tmp_path / "mix.wav"), str(tmp_path / "stems"), stems=["drums", "bass"])
+    assert [s["stem"] for s in r["stems"]] == ["drums", "bass"]
+    assert sorted(p.name for p in (tmp_path / "stems").iterdir()) == ["bass.wav", "drums.wav"]
+    info = sf.info(str(tmp_path / "stems" / "bass.wav"))
+    assert info.subtype == "FLOAT" and info.samplerate == 44100 and info.channels == 2
+    assert abs(info.duration - 8.0) < 0.01
+    bass = next(s for s in r["stems"] if s["stem"] == "bass")
+    assert bass["lufs"] is not None and bass["lufs"] > -40, "the bass line lands in the bass stem"
+
+
+@pytest.mark.skipif(not separation.is_installed(), reason="demucs not installed (setup-sidecar --with-separation)")
+def test_an_accelerator_failure_reruns_on_cpu_and_says_so(tmp_path, monkeypatch):
+    import demucs.apply
+
+    real = demucs.apply.apply_model
+
+    def accelerator_lacks_an_op(*args, **kw):
+        # Demucs calls apply_model recursively with positional arguments: only the device keyword matters.
+        if kw.get("device") == "mps":
+            raise RuntimeError("op not implemented for 'mps'")
+        return real(*args, **kw)
+
+    monkeypatch.setattr(separation, "_device", lambda: "mps")
+    monkeypatch.setattr(demucs.apply, "apply_model", accelerator_lacks_an_op)
+    _mix(tmp_path / "mix.wav", seconds=3.0)
+    r = separation.separate(str(tmp_path / "mix.wav"), str(tmp_path / "stems"), stems=["bass"])
+    assert r["device"] == "cpu_fallback" and r["fallbackFrom"] == "mps"
+    assert "not implemented" in r["fallbackError"]
+    assert [s["stem"] for s in r["stems"]] == ["bass"]