diff --git a/.trivyignore b/.trivyignore
index 17b6d25b..81f03eac 100644
--- a/.trivyignore
+++ b/.trivyignore
@@ -35,3 +35,20 @@ DS-0002
# update. Take the bump the next time the lock moves for another reason, and
# drop this entry then.
CVE-2026-63374
+
+# CVE-2026-97687 (traffic interception through an HTTPS proxy's TLS
+# configuration) and CVE-2026-97689 (denial of service through unbounded
+# memory): urllib3, fixed in 2.8.0; the lock pins 2.7.0.
+#
+# StemDeck's own requests all go through the standard library's urllib.
+# urllib3 is here only through requests, which audio-separator, librosa's
+# pooch and Whisper's tiktoken use to download models and data from fixed
+# hosts (GitHub, Hugging Face, OpenAI's CDN). The first needs an HTTPS proxy
+# configured, the second a hostile server on one of those downloads.
+#
+# Not bumped now for the same reason as CVE-2026-63374: any uv.lock change
+# sends every existing desktop install to a full download instead of an
+# in-app update, and 0.19.0 already did that two days before 0.19.1. Take the
+# bump the next time the lock moves for another reason, and drop these then.
+CVE-2026-97687
+CVE-2026-97689
diff --git a/app/api/jobs.py b/app/api/jobs.py
index bb7a3ae3..eecca686 100644
--- a/app/api/jobs.py
+++ b/app/api/jobs.py
@@ -16,7 +16,7 @@
from fastapi import APIRouter, HTTPException, Request
from fastapi.responses import JSONResponse, Response
-from pydantic import BaseModel, Field, field_validator
+from pydantic import BaseModel, Field, StrictBool, field_validator
from app.core.config import (
DISCOGS_LOOKUP_BUDGET_SEC,
@@ -44,6 +44,7 @@
from app.core.registry import persist as registry_persist
from app.core.registry import register_if_capacity as registry_register_if_capacity
from app.core.registry import remove as registry_remove
+from app.core.registry import set_favorite as registry_set_favorite
from app.core.registry import set_trashed as registry_set_trashed
from app.core.settings import (
get_acoustid_api_key,
@@ -68,6 +69,7 @@
copy_lyrics,
find_lyrics,
keep_answer,
+ lookup_lyrics,
lyrics_path,
lyrics_settled,
read_candidates,
@@ -423,6 +425,25 @@ def restore_job(job_id: str) -> dict:
return {"job_id": job.id, "trashed_at": job.trashed_at}
+class FavoriteBody(BaseModel):
+ """Strict, so a string such as "false" is refused rather than read as true."""
+
+ favorite: StrictBool
+
+
+@router.put("/{job_id}/favorite")
+def set_favorite(job_id: str, body: FavoriteBody) -> dict:
+ """Mark a job as a favourite or take it back out (#734). Kept on the server
+ so the desktop and the phone share one answer."""
+ if not JOB_ID_RE.match(job_id):
+ raise HTTPException(status_code=404, detail="job not found")
+ job = registry_set_favorite(job_id, body.favorite)
+ if job is None:
+ raise HTTPException(status_code=404, detail="job not found")
+ registry_persist(JOBS_DIR)
+ return {"job_id": job.id, "favorite": job.favorite}
+
+
@router.get("/{job_id}")
def get_job(job_id: str) -> dict:
"""Get the current state of a job by ID."""
@@ -1174,6 +1195,84 @@ def get_lyrics(job_id: str) -> Response:
raise HTTPException(status_code=404, detail="no lyrics")
+class LookupBand(BaseModel):
+ """The band saved on the track from the artist box, which lives in the
+ studio's own store and may not be on the job yet."""
+
+ id: str = Field(pattern=r"^Q\d{1,12}$")
+ name: str = Field(default="", max_length=300)
+ englishName: str = Field(default="", max_length=300) # noqa: N815 (the store's own key)
+
+
+class LyricsLookupBody(BaseModel):
+ band: LookupBand | None = None
+
+
+# Jobs whose lyrics the tab is looking up now, so a second request for the
+# same track waits for the first rather than asking LRCLIB twice.
+_LYRICS_LOOKUPS: set[str] = set()
+
+
+@router.post("/{job_id}/lyrics/lookup")
+async def lookup_lyrics_route(job_id: str, body: LyricsLookupBody | None = None) -> Response:
+ """Look the track's lyrics up on LRCLIB now, for the Lyrics tab (#719).
+
+ The tab used to search LRCLIB itself, with its own copy of the rules that
+ decide which version is this song by this artist and which length fits.
+ The two copies had to be kept equal by hand, and when they drifted the
+ same track could get lyrics at import and none in the tab. This runs the
+ import's own lookup instead, keeps what it finds the way the import does,
+ and answers exactly as GET .../lyrics would afterwards.
+
+ Only ever asked when the tab is opened on a track with no lyrics, or the
+ user presses Look up again: LRCLIB is never reached on its own. 502 when
+ LRCLIB cannot be reached, so the tab can offer to try again; 404 with
+ {"nothing_known": true} when the track says too little to look up.
+ """
+ job, job_dir = _lyrics_job(job_id)
+ if await asyncio.to_thread(lyrics_path(job_dir).is_file):
+ return await asyncio.to_thread(get_lyrics, job_id)
+ if job_id in _LYRICS_LOOKUPS:
+ raise HTTPException(status_code=409, detail="already looking")
+ band = body.band.model_dump() if body and body.band else None
+ query = build_query(job, band=band)
+ if query is None:
+ return JSONResponse(
+ {"detail": "nothing to look up", "others": [], "nothing_known": True}, status_code=404
+ )
+ _LYRICS_LOOKUPS.add(job_id)
+ try:
+ answer = await asyncio.wait_for(
+ asyncio.to_thread(
+ lookup_lyrics,
+ query,
+ cancelled=lambda: registry_get(job_id) is not job,
+ fallback_title=job.title or "",
+ ),
+ timeout=LYRICS_LOOKUP_BUDGET_SEC + TIMEOUT_LYRICS_LOOKUP + 1,
+ )
+ except asyncio.TimeoutError:
+ logger.info("[%s] lyrics lookup timed out", job_id)
+ raise HTTPException(status_code=502, detail="lyrics service unreachable") from None
+ except Exception:
+ logger.info("[%s] lyrics lookup failed", job_id, exc_info=True)
+ raise HTTPException(status_code=502, detail="lyrics service unreachable") from None
+ finally:
+ _LYRICS_LOOKUPS.discard(job_id)
+ if registry_get(job_id) is not job:
+ raise HTTPException(status_code=404, detail="job not found")
+ if (
+ answer is not None
+ and not lyrics_path(job_dir).is_file()
+ and await asyncio.to_thread(keep_answer, job, job_dir, answer)
+ ):
+ registry_persist(JOBS_DIR)
+ try:
+ return await asyncio.to_thread(get_lyrics, job_id)
+ except HTTPException:
+ return JSONResponse({"detail": "no lyrics", "others": []}, status_code=404)
+
+
class LyricsOffsetBody(BaseModel):
"""How many seconds later than their own timing the lyrics are shown:
negative for earlier, 0 for their own timing again."""
diff --git a/app/core/config.py b/app/core/config.py
index 104f67cb..63ebf7c4 100644
--- a/app/core/config.py
+++ b/app/core/config.py
@@ -28,11 +28,23 @@ def _env_path_opt(name: str) -> Path | None:
return Path(raw).expanduser().resolve() if raw else None
+# Why torch could not be loaded at the last probe, or None if it loaded (#730).
+# Refreshed on every probe rather than decided once, so a repaired install
+# clears it without a restart.
+_torch_load_error: str | None = None
+
+
+def torch_load_error() -> str | None:
+ """The last probe's reason torch is installed but unusable, if any."""
+ return _torch_load_error
+
+
def available_torch_devices() -> list[str]:
"""Compute devices this machine can actually use, best-first. CPU is always
present; cuda/mps depend on the hardware + installed torch build. The
Settings UI uses this to disable options that aren't available/detected so
a user can't pick an impossible device."""
+ global _torch_load_error
devices: list[str] = []
try:
import torch
@@ -41,8 +53,21 @@ def available_torch_devices() -> list[str]:
devices.append("cuda")
if getattr(torch.backends, "mps", None) and torch.backends.mps.is_available():
devices.append("mps")
+ _torch_load_error = None
except ImportError:
pass
+ except Exception as exc: # noqa: BLE001 -- any failure here must not stop the server
+ # Installed but unloadable: on Windows a CUDA DLL left behind by a
+ # half-reverted install raises OSError (WinError 127) from torch's own
+ # DLL loader (#723). Catching only ImportError let that kill startup
+ # and every /api/settings call. The server has to come up so it can
+ # say what is wrong. Logged loudly once per distinct cause, because
+ # separation cannot run on any device until torch is repaired, CPU
+ # included, and a quiet fallback would hide exactly that.
+ reason = f"{type(exc).__name__}: {exc}"
+ if reason != _torch_load_error:
+ logger.error("torch is installed but could not be loaded: %s", reason, exc_info=True)
+ _torch_load_error = reason
devices.append("cpu")
return devices
diff --git a/app/core/models.py b/app/core/models.py
index 77e4abc9..e51c84d2 100644
--- a/app/core/models.py
+++ b/app/core/models.py
@@ -306,6 +306,16 @@ class Job:
# A timestamp rather than a bool so the Trash can say when, and so a future
# auto-purge has something to work from.
trashed_at: float | None = None
+ # Whether the user marked this track as a favourite, or None if no
+ # client has said either way yet (#734).
+ #
+ # Server-side for the same reason as trashed_at: favourites lived only in
+ # the desktop page's catalog store, so the phone, which builds its library
+ # from GET /api/jobs, had no way to set one or to filter by them. None
+ # rather than False lets the desktop tell "never recorded here" from
+ # "taken back out", so it can hand up favourites it set before this field
+ # existed without undoing one removed on the phone.
+ favorite: bool | None = None
# Set by POST /api/jobs/{id}/cancel; consumed by pipeline stages.
# Not surfaced via to_state() -- it's internal control state.
cancel_requested: bool = False
@@ -366,6 +376,7 @@ def to_state(self) -> dict[str, Any]:
"stage_timings": self.stage_timings,
"vocal_split": self.vocal_split,
"trashed_at": self.trashed_at,
+ "favorite": self.favorite,
"created_at": self.created_at,
}
diff --git a/app/core/registry.py b/app/core/registry.py
index 1a732c3e..9b16793f 100644
--- a/app/core/registry.py
+++ b/app/core/registry.py
@@ -107,6 +107,16 @@ def set_trashed(job_id: str, trashed: bool) -> Job | None:
return job
+def set_favorite(job_id: str, favorite: bool) -> Job | None:
+ """Mark a job as a favourite, or take it back out (#734)."""
+ with _lock:
+ job = _jobs.get(job_id)
+ if job is None:
+ return None
+ job.favorite = favorite
+ return job
+
+
def all_jobs() -> dict[str, Job]:
"""Return a snapshot of the registry for sweep / cleanup."""
with _lock:
diff --git a/app/main.py b/app/main.py
index eb050740..238d576b 100644
--- a/app/main.py
+++ b/app/main.py
@@ -39,6 +39,7 @@
available_torch_devices,
configure_portable_environment,
ensure_runtime_dirs,
+ torch_load_error,
)
from app.core.logging_setup import configure_logging
from app.core.process import process_exists as _process_exists
@@ -393,6 +394,9 @@ def _settings_payload() -> dict[str, object]:
"demucs_device": get_demucs_device_choice(),
"demucs_device_resolved": get_demucs_device(),
"demucs_devices_available": available_torch_devices(),
+ # Set when torch is installed but cannot load, which stops separation
+ # on every device (#730). Read after the probe above refreshed it.
+ "torch_error": torch_load_error(),
}
@@ -915,18 +919,21 @@ def download_logs_zip() -> StreamingResponse:
# Content-Security-Policy. Defense-in-depth so an injected string in the webview
# can't run script (and, in the desktop app, reach the exposed Tauri IPC) — #171.
# script-src has no 'unsafe-inline'/'eval': all JS is same-origin modules and the
-# inline scripts/onclick were moved out. 'unsafe-inline' is allowed for *styles*
+# inline scripts/onclick were moved out. 'wasm-unsafe-eval' lets WebAssembly
+# compile, which the Signalsmith tempo stage in the audio worklet needs (#729);
+# it does not re-enable JS eval, new Function or string timers. 'unsafe-inline' is allowed for *styles*
# only (the UI sets many style attributes). Allowances:
# connect-src -> same-origin API/SSE, the GitHub update check, Tauri IPC,
-# Wikidata/Wikipedia for the artist box the now-playing card
-# opens, and LRCLIB for the Lyrics tab (#699). All four are
-# read-only public APIs, asked only about the open track, and
-# sent only an artist and a song name.
+# and Wikidata/Wikipedia for the artist box the now-playing
+# card opens. Read-only public APIs, asked only about the
+# open track, and sent only an artist and a song name. Not
+# LRCLIB: the Lyrics tab asks the server to look lyrics up
+# (#719), so the page never reaches it.
# img-src https: -> remote YouTube/SoundCloud thumbnails
# style/font -> the Google Fonts
_CSP = (
"default-src 'self'; "
- "script-src 'self'; "
+ "script-src 'self' 'wasm-unsafe-eval'; "
"style-src 'self' 'unsafe-inline' https://fonts.googleapis.com; "
"font-src 'self' https://fonts.gstatic.com data:; "
"img-src 'self' data: blob: https:; "
@@ -936,8 +943,7 @@ def download_logs_zip() -> StreamingResponse:
# (#186). They are inline/same-origin schemes, not network endpoints, so
# they add no exfiltration channel — script-src below stays locked.
"connect-src 'self' https://api.github.com ipc: http://ipc.localhost data: blob: "
- "https://www.wikidata.org https://query.wikidata.org https://*.wikipedia.org "
- "https://lrclib.net; "
+ "https://www.wikidata.org https://query.wikidata.org https://*.wikipedia.org; "
"object-src 'none'; base-uri 'self'; frame-ancestors 'none'; form-action 'self'"
)
diff --git a/app/pipeline/analyze.py b/app/pipeline/analyze.py
index 60d60c13..2acbb3f1 100644
--- a/app/pipeline/analyze.py
+++ b/app/pipeline/analyze.py
@@ -54,6 +54,34 @@
# and minor is the better default when the call is genuinely ambiguous.
_MINOR_TIE_BREAK_FRAC = 0.05
+# How much the song's edges count against the correlation when choosing
+# between close candidates, a key and its relative above all. Tuned on
+# tests/keyset.py: the reporter's
+# i-VI-III-VII leads its relative major by up to 0.22 in correlation and
+# trails it by about 0.8 in edge fit, and in every song detected correctly the
+# edges agree with the correlation, so weighing them in never flips those.
+_EDGE_WEIGHT = 0.4
+# Keys this close to the best correlation, and their relatives, are all
+# candidates when the edges are weighed in. A loop like i-VII-VI-VII puts the
+# VII's own key ahead of the tonic's by a hair, and neither is the other's
+# relative.
+_FAMILY_WINDOW = 0.1
+# Without edges, a relative pair this close in correlation counts as a tie.
+_RELATIVE_MARGIN = 0.15
+# Harmonic minor is reported when the raised seventh outweighs the flat one by
+# this much and reaches this share of the loudest pitch class. On
+# tests/keyset.py the ratio is at most 0.77 for natural minor and at least 1.54
+# for harmonic minor, on the mix and on stems; the floor only keeps two
+# near-silent pitch classes from deciding it.
+_HARMONIC_RATIO = 1.3
+_HARMONIC_FLOOR = 0.1
+# A correlation gap this wide over the nearest unrelated key is full
+# confidence; an edge margin this wide settles a relative pair outright.
+_CONFIDENCE_FULL_GAP = 0.25
+_EDGE_CONFIDENT_MARGIN = 0.3
+# How much of the start and end of the music counts as its edges.
+_EDGE_SECONDS = 4.0
+
def _correlate(profile: tuple[float, ...], chroma: list[float], shift: int) -> float:
n = len(profile)
@@ -68,66 +96,131 @@ def _correlate(profile: tuple[float, ...], chroma: list[float], shift: int) -> f
return num / (denom_p * denom_c)
-def _detect_key(chroma_mean: list[float]) -> tuple[str, str, int]:
- """Find the best-matching key by combining profile correlation with
- root prominence. The Pearson correlation alone is fooled by relative
- keys whose diatonic notes happen to overlap with the song's loud
- pitches but whose own tonic is weak (e.g. picking A minor for an
- E-minor song because E is its 5th and D is its 4th). Weighting by
- the candidate root's chroma value forces the algorithm to also
- confirm 'is this proposed tonic actually loud in the audio?'.
- Logs the chroma vector and top-5 candidates for diagnostics.
+def _key_candidates(chroma_mean: list[float]) -> list[tuple[float, int, str]]:
+ """Every key's Pearson correlation with its profile, best first, as
+ (correlation, root, "maj" | "min")."""
+ out = []
+ for shift in range(12):
+ out.append((_correlate(_MAJOR_PROFILE, chroma_mean, shift), shift, "maj"))
+ out.append((_correlate(_MINOR_PROFILE, chroma_mean, shift), shift, "min"))
+ out.sort(key=lambda c: c[0], reverse=True)
+ return out
+
+
+def _relative(root: int, mode: str) -> tuple[int, str]:
+ return ((root + 9) % 12, "min") if mode == "maj" else ((root + 3) % 12, "maj")
+
+
+def _tonic_fit(root: int, mode: str, edges: list[tuple[list[float], list[float]]]) -> float:
+ """How much the song's edges sound like this key's home chord.
+
+ Each edge is (chroma, bass chroma) averaged over a few seconds at the start
+ or the end of the music, each scaled to a maximum of 1. A song starts and
+ ends on its tonic far more often than on any other chord, and that is the
+ one thing a whole-song histogram cannot show: a minor loop such as
+ i-VI-III-VII uses exactly its relative major's notes (#726).
+ """
+ triad = {root, (root + (4 if mode == "maj" else 3)) % 12, (root + 7) % 12}
+ score = 0.0
+ for harmony, bass in edges:
+ inside = sum(harmony[i] for i in triad) / 3
+ outside = sum(harmony[i] for i in range(12) if i not in triad) / 9
+ score += inside - outside + bass[root]
+ return score / len(edges)
+
+
+def _detect_key(
+ chroma_mean: list[float],
+ edges: list[tuple[list[float], list[float]]] | None = None,
+) -> tuple[str, str, int]:
+ """Find the key: profile correlation narrows it to a few close candidates,
+ and the song's edges decide between them, a key and its relative above all.
+
+ It used to multiply each key's correlation by how loud its root was. In a
+ minor song the relative major's root is the minor chord's third, and is
+ also in two of the other three chords of a typical loop, so it is usually
+ the louder one: every i-VI-III-VII progression came out as its relative
+ major, at up to 100% confidence (#726). Correlation alone is scale
+ invariant and does not have that pull; what it cannot do is tell relative
+ keys apart, which is the edges' job.
+
+ `edges` is optional: without it a near-tie between a key and its relative
+ falls back on the pop/rock minor prior.
Returns (label, scale_name, confidence_pct).
- - label: e.g. "G# maj"
- - scale_name: "Major" or "Natural Minor"
- - confidence_pct: 0-100, derived from the gap between the winning
- candidate and the runner-up, normalized so a clear
- win ranks high and a near-tie ranks low."""
- raw: list[tuple[float, float, str, int]] = [] # (weighted, pearson, label, root_idx)
- for shift in range(12):
- root_strength = chroma_mean[shift]
- pearson_maj = _correlate(_MAJOR_PROFILE, chroma_mean, shift)
- pearson_min = _correlate(_MINOR_PROFILE, chroma_mean, shift)
- # Multiplicative root weighting. Pearson can be negative; when
- # it is, a low-chroma root makes things less negative (closer to
- # zero), which is actually the desired ordering.
- raw.append((pearson_maj * root_strength, pearson_maj, f"{_PITCHES[shift]} maj", shift))
- raw.append((pearson_min * root_strength, pearson_min, f"{_PITCHES[shift]} min", shift))
- raw.sort(key=lambda x: x[0], reverse=True)
-
- # Diagnostic log: chroma profile + top 5 candidates with both raw
- # and weighted scores. Lets us see what the algorithm is "hearing".
+ - label: e.g. "G# maj"
+ - scale_name: "Major", "Natural Minor" or "Harmonic Minor"
+ - confidence_pct: 0-100
+ """
+ candidates = _key_candidates(chroma_mean)
+ best = candidates[0]
+ rel_root, rel_mode = _relative(best[1], best[2])
+ rel = next(c for c in candidates if c[1] == rel_root and c[2] == rel_mode)
+
chroma_str = ", ".join(f"{_PITCHES[i]}={chroma_mean[i]:.3f}" for i in range(12))
- top5_str = ", ".join(
- f"{label}={weighted:+.3f}(p{pearson:+.2f}*r{chroma_mean[idx]:.2f})"
- for weighted, pearson, label, idx in raw[:5]
- )
+ top5_str = ", ".join(f"{_PITCHES[r]} {m}={p:+.3f}" for p, r, m in candidates[:5])
logger.debug("chroma: %s", chroma_str)
logger.debug("key candidates (top 5): %s", top5_str)
- # Pick best major and best minor for the tie-break, both by the
- # weighted score.
- best_maj = next(c for c in raw if c[2].endswith("maj"))
- best_min = next(c for c in raw if c[2].endswith("min"))
-
- gap = abs(best_maj[0] - best_min[0])
- threshold = max(abs(best_maj[0]), abs(best_min[0])) * _MINOR_TIE_BREAK_FRAC
- # Near-tie -> prefer minor (pop/rock prior); clear winner -> use it.
- winner = (best_maj if best_maj[0] > best_min[0] else best_min) if gap > threshold else best_min
-
- # Confidence: gap between the winner and the runner-up that *isn't*
- # the relative major/minor of the winner (those will always be near-
- # ties with the algorithm's profile-correlation approach, so they
- # tell us nothing about real ambiguity). Normalize so a healthy 0.15
- # gap = 100% confident; tiny gap = 0%.
- runner_up = next(c for c in raw if c[2] != winner[2])
- confidence_score = winner[0] - runner_up[0]
- confidence_pct = max(0, min(100, round(confidence_score / 0.15 * 100)))
-
- label = winner[2]
- scale_name = "Major" if label.endswith("maj") else "Natural Minor"
- return label, scale_name, confidence_pct
+ winner = best
+ # How clearly the winner was separated from its closest rival, 0-1.
+ clarity = 1.0
+ if edges:
+ by_key = {(c[1], c[2]): c for c in candidates}
+ pool = set()
+ for c in candidates:
+ if best[0] - c[0] <= _FAMILY_WINDOW:
+ pool.add((c[1], c[2]))
+ pool.add(_relative(c[1], c[2]))
+ scored = sorted(
+ (
+ (by_key[k][0] + _EDGE_WEIGHT * _tonic_fit(k[0], k[1], edges), by_key[k])
+ for k in pool
+ ),
+ key=lambda s: s[0],
+ reverse=True,
+ )
+ logger.debug(
+ "with edges: %s",
+ ", ".join(f"{_PITCHES[c[1]]} {c[2]}={score:.3f}" for score, c in scored[:5]),
+ )
+ winner = scored[0][1]
+ runner = scored[1][0] if len(scored) > 1 else scored[0][0] - _EDGE_CONFIDENT_MARGIN
+ clarity = min(1.0, (scored[0][0] - runner) / _EDGE_CONFIDENT_MARGIN)
+ elif best[0] - rel[0] < _RELATIVE_MARGIN:
+ # Near-tie with nothing else to go on: prefer minor, the pop/rock
+ # prior ("Come As You Are" hammers the open D of an E minor song).
+ threshold = max(abs(best[0]), abs(rel[0])) * _MINOR_TIE_BREAK_FRAC
+ if best[0] - rel[0] <= threshold and rel[2] == "min":
+ winner = rel
+ clarity = 0.5
+
+ root, mode = winner[1], winner[2]
+ label = f"{_PITCHES[root]} {mode}"
+
+ scale_name = "Major"
+ if mode == "min":
+ # The raised seventh is the harmonic minor's signature (a major V);
+ # the natural minor's is the flat seventh. Only called when the raised
+ # one clearly dominates and is actually sounding.
+ raised = chroma_mean[(root + 11) % 12]
+ flat = chroma_mean[(root + 10) % 12]
+ peak = max(chroma_mean) or 1.0
+ harmonic = raised > _HARMONIC_RATIO * flat and raised > _HARMONIC_FLOOR * peak
+ scale_name = "Harmonic Minor" if harmonic else "Natural Minor"
+
+ # Confidence: how clearly the key family won, against the best candidate
+ # that is neither the winner nor its relative (relative keys correlate
+ # alike by construction, so they say nothing about the family), then
+ # scaled by how clearly the pair itself was separated.
+ # With edges, the margin over the runner-up already covers both, since
+ # every close candidate was in the running.
+ if edges:
+ return label, scale_name, round(clarity * 100)
+ others = [c for c in candidates if (c[1], c[2]) not in {(best[1], best[2]), (rel[1], rel[2])}]
+ family_gap = best[0] - others[0][0]
+ confidence = min(1.0, max(0.0, family_gap / _CONFIDENCE_FULL_GAP)) * clarity
+ return label, scale_name, round(confidence * 100)
def _measure_loudness(y: object, sr: int) -> tuple[float | None, float | None]:
@@ -261,12 +354,11 @@ def analyze(job: Job, source: Path) -> tuple[int | None, str | None]:
# chroma_cqt is constant-Q based — better pitch resolution than
# chroma_stft, especially in the bass register where the open
# strings of a guitar live.
- chroma = librosa.feature.chroma_cqt(y=y_harmonic, sr=sr)
- chroma_mean = chroma.mean(axis=1).tolist()
- if any(chroma_mean):
- key, scale, key_confidence = _detect_key(chroma_mean)
- else:
- key, scale, key_confidence = None, None, None
+ # The decode stops at 180 s, so the song's last chord is only among
+ # the evidence when the whole song fitted.
+ whole_song = y.size < 179.5 * sr
+ detected = detect_key_from_audio(y_harmonic, None, sr, whole_song=whole_song)
+ key, scale, key_confidence = detected if detected else (None, None, None)
# LUFS / peak. Computed on the same 22 kHz mono buffer; this
# loses a few dB of accuracy vs full-sample-rate stereo, but
@@ -310,3 +402,143 @@ def analyze(job: Job, source: Path) -> tuple[int | None, str | None]:
logger.exception("analyze failed for job %s", job.id)
_set(job, stage="Analysis skipped")
return None, None
+
+
+def _key_evidence(
+ harmony: object,
+ bass: object | None,
+ sr: int,
+ whole_song: bool,
+) -> tuple[list[float], list[tuple[list[float], list[float]]]]:
+ """The whole-song chroma, and the chroma and bass chroma at the edges of
+ the music, for _detect_key.
+
+ `bass` is the separated bass stem when there is one. Without it, the low
+ three octaves of `harmony` stand in for it. The end of the song is only an
+ edge when `whole_song`: a decode capped part way through ends mid-song.
+ """
+ import librosa
+ import numpy as np
+
+ # 93 ms frames. Key needs no finer: measured on a 9.5 min track's stems,
+ # 512 took 8.6 s for both chromas and 2048 took 4.1 s, with the same
+ # score on tests/keyset.py.
+ hop = 2048
+ chroma = librosa.feature.chroma_cqt(y=harmony, sr=sr, hop_length=hop)
+ low = bass if bass is not None else harmony
+ bass_chroma = librosa.feature.chroma_cqt(
+ y=low, sr=sr, hop_length=hop, fmin=librosa.note_to_hz("C1"), n_octaves=3
+ )
+ level = librosa.feature.rms(y=harmony if bass is None else harmony + bass, hop_length=hop)[0]
+ frames = min(chroma.shape[1], bass_chroma.shape[1], level.shape[0])
+ chroma, bass_chroma, level = chroma[:, :frames], bass_chroma[:, :frames], level[:frames]
+
+ # Music, not the silence or count-in before it: frames within 20 dB of
+ # the loudest.
+ active = np.flatnonzero(level > 0.1 * (level.max() or 1.0))
+ span = max(1, int(_EDGE_SECONDS * sr / hop))
+
+ def region(a: int, b: int) -> tuple[list[float], list[float]]:
+ h = chroma[:, a:b].mean(axis=1)
+ lo = bass_chroma[:, a:b].mean(axis=1)
+ return (h / (h.max() or 1.0)).tolist(), (lo / (lo.max() or 1.0)).tolist()
+
+ edges = []
+ if active.size:
+ start = int(active[0])
+ edges.append(region(start, start + span))
+ if whole_song:
+ end = int(active[-1]) + 1
+ edges.append(region(max(0, end - span), end))
+ return chroma.mean(axis=1).tolist(), edges
+
+
+def detect_key_from_audio(
+ harmony: object, bass: object | None, sr: int, whole_song: bool = True
+) -> tuple[str, str, int] | None:
+ """Key, scale and confidence from mono audio, or None for silence."""
+ chroma_mean, edges = _key_evidence(harmony, bass, sr, whole_song)
+ if not any(chroma_mean):
+ return None
+ return _detect_key(chroma_mean, edges)
+
+
+# Stems that carry harmony. Vocals count for half: a melody leans on the tonic
+# at phrase ends, but it also dwells on passing notes.
+_HARMONY_STEMS = {"guitar": 1.0, "piano": 1.0, "other": 1.0, "vocals": 0.5}
+# The stems are decoded whole up to this long, so the end of the song counts.
+_STEM_KEY_MAX_SECONDS = 600.0
+
+
+def refine_key_from_stems(job: Job, stems_dir: Path) -> None:
+ """Detect the key again from the separated stems, and keep it if it works.
+
+ The first estimate comes from the full mix before separation, so the key
+ shows while separation runs. The stems are better evidence: the bass line
+ on its own says which note is home, drums no longer smear the chroma, and
+ the whole song, including its last chord, is available rather than the
+ first 180 s. Any failure keeps the first estimate.
+ """
+ import numpy as np
+
+ sr = 22050
+ try:
+ harmony = None
+ heard = []
+ longest = 0
+ for name, weight in _HARMONY_STEMS.items():
+ path = stems_dir / f"{name}.wav"
+ if not path.is_file():
+ continue
+ loaded = _load_audio_ffmpeg(path, sr=sr, duration=_STEM_KEY_MAX_SECONDS)
+ if loaded is None:
+ continue
+ y = loaded[0] * weight
+ longest = max(longest, y.size)
+ harmony = y if harmony is None else _sum_padded(harmony, y)
+ heard.append(name)
+ if harmony is None:
+ logger.info("key from stems: no harmony stems for job %s, keeping %s", job.id, job.key)
+ return
+ bass = None
+ bass_path = stems_dir / "bass.wav"
+ if bass_path.is_file():
+ loaded = _load_audio_ffmpeg(bass_path, sr=sr, duration=_STEM_KEY_MAX_SECONDS)
+ if loaded is not None:
+ bass = loaded[0]
+ harmony, bass = _pad_pair(harmony, bass)
+ if bass is None:
+ logger.info(
+ "key from stems: no bass stem for job %s, using the harmony's low end", job.id
+ )
+ whole = longest < (_STEM_KEY_MAX_SECONDS - 1) * sr
+ result = detect_key_from_audio(harmony.astype(np.float32), bass, sr, whole_song=whole)
+ if result is None:
+ return
+ key, scale, confidence = result
+ if key != job.key or scale != job.scale:
+ logger.info(
+ "key from stems (%s%s): %s %s %s%% (mix said %s %s)",
+ "+".join(heard),
+ "+bass" if bass is not None else "",
+ key,
+ scale,
+ confidence,
+ job.key,
+ job.scale,
+ )
+ _set(job, key=key, scale=scale, key_confidence=confidence)
+ except Exception:
+ logger.exception("key from stems failed for job %s, keeping %s", job.id, job.key)
+
+
+def _sum_padded(a: object, b: object) -> object:
+ a, b = _pad_pair(a, b)
+ return a + b
+
+
+def _pad_pair(a: object, b: object) -> tuple[object, object]:
+ import numpy as np
+
+ n = max(a.size, b.size) # type: ignore[attr-defined]
+ return np.pad(a, (0, n - a.size)), np.pad(b, (0, n - b.size)) # type: ignore[attr-defined]
diff --git a/app/pipeline/runner.py b/app/pipeline/runner.py
index 83a70b0f..ab484902 100644
--- a/app/pipeline/runner.py
+++ b/app/pipeline/runner.py
@@ -21,7 +21,7 @@
from app.core.redact import redact
from app.core.registry import is_upload, set_proc
from app.core.registry import persist as persist_registry
-from app.pipeline.analyze import analyze
+from app.pipeline.analyze import analyze, refine_key_from_stems
from app.pipeline.beatgrid import compute_beat_grid
from app.pipeline.collect import (
cleanup_source,
@@ -222,6 +222,12 @@ def _run_common(job: Job, source: Path, job_dir: Path) -> None:
cleanup_source(job_dir)
job.stems = [{"name": name, "url": f"/api/jobs/{job.id}/stems/{name}.wav"} for name in found]
_check_cancel(job)
+ # The key was first estimated from the mix, before separation. The stems
+ # are better evidence, the bass line above all (#726). Keeps the first
+ # estimate on any failure. Counted in "post", not as a stage of its own:
+ # the timings' order is a contract (tests/test_identify_regressions.py).
+ refine_key_from_stems(job, stems_dir)
+ _check_cancel(job)
_set(job, stage="Mixing tracks...")
original_path = make_original_track(job, job_dir, stems_dir)
if original_path is not None:
diff --git a/desktop/src-tauri/Cargo.lock b/desktop/src-tauri/Cargo.lock
index b6a073b8..0a8becdf 100644
--- a/desktop/src-tauri/Cargo.lock
+++ b/desktop/src-tauri/Cargo.lock
@@ -103,6 +103,12 @@ version = "0.22.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6"
+[[package]]
+name = "base64"
+version = "0.23.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ac07cdecf99051d9a5238b80f35af32cdeba5b336e55d957b318b50137e18da5"
+
[[package]]
name = "bit-set"
version = "0.8.0"
@@ -2503,11 +2509,11 @@ checksum = "19f132c84eca552bf34cab8ec81f1c1dcc229b811638f9d283dceabe58c5569e"
[[package]]
name = "plist"
-version = "1.9.0"
+version = "1.10.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "092791278e026273c1b65bbdcfbba3a300f2994c896bd01ab01da613c29c46f1"
+checksum = "2896bade328c13f7042a297ea5ac5b0951f6cf989dea5f32c2fd98da398195cb"
dependencies = [
- "base64 0.22.1",
+ "base64 0.23.1",
"indexmap 2.14.0",
"quick-xml",
"serde",
@@ -2635,9 +2641,9 @@ dependencies = [
[[package]]
name = "quick-xml"
-version = "0.39.3"
+version = "0.42.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "721da970c312655cde9b4ffe0547f20a8494866a4af5ff51f18b7c633d0c870b"
+checksum = "41b1177fdf999d2321d3fb46ff47159d9c1fb9ad66a4879f8c50a0b504615e9b"
dependencies = [
"memchr",
]
@@ -2990,9 +2996,9 @@ dependencies = [
[[package]]
name = "rustls"
-version = "0.23.40"
+version = "0.23.45"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ef86cd5876211988985292b91c96a8f2d298df24e75989a43a3c73f2d4d8168b"
+checksum = "0d41d731c7d2f962d1ccc364cec258de3c0e93b38c2fb3ba97ac74513048d634"
dependencies = [
"once_cell",
"ring",
@@ -3014,9 +3020,9 @@ dependencies = [
[[package]]
name = "rustls-webpki"
-version = "0.103.13"
+version = "0.103.15"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "61c429a8649f110dddef65e2a5ad240f747e85f7758a6bccc7e5777bd33f756e"
+checksum = "f3c3cf1d8b1e7d4927e2d154c3fcb02979afb9939629c62cd9048d4f07b60ac2"
dependencies = [
"ring",
"rustls-pki-types",
diff --git a/desktop/src-tauri/src/main.rs b/desktop/src-tauri/src/main.rs
index b1ad729c..442e0c0f 100644
--- a/desktop/src-tauri/src/main.rs
+++ b/desktop/src-tauri/src/main.rs
@@ -1,6 +1,8 @@
mod certs;
mod dragout;
mod dropin;
+#[cfg(any(not(target_os = "macos"), test))]
+mod torchswap;
use flate2::read::GzDecoder;
use serde::{Deserialize, Serialize};
@@ -1945,6 +1947,27 @@ fn ensure_torch_device(
#[cfg(not(target_os = "macos"))]
{
+ let site = torch_site_packages(&python);
+ if site.is_none() {
+ append_to_setup_log(
+ &data_dir,
+ "could not locate site-packages; torch swaps overlay",
+ );
+ }
+ // A swap that was interrupted (crash, forced quit, a rollback that did
+ // not finish) is put back before anything else looks at torch.
+ if let Some(site) = site.as_deref().filter(|s| torchswap::has_backup(s)) {
+ match torchswap::restore(site) {
+ Ok(()) => append_to_setup_log(
+ &data_dir,
+ "restored the bundled torch left aside by an interrupted swap",
+ ),
+ Err(e) => append_to_setup_log(
+ &data_dir,
+ &format!("could not restore an interrupted torch swap ({e})"),
+ ),
+ }
+ }
let setup = match detect_nvidia_gpu(&data_dir) {
Some((gpu_name, cuda_version, compute_cap)) => {
// Try each candidate wheel in turn. A build that installs but
@@ -1959,7 +1982,20 @@ fn ensure_torch_device(
// reads in a bug report and sends them after the wrong thing
// (#502: the install had been killed mid-download).
let mut cuda_installed = false;
- for tag in &candidates {
+ // One entry per candidate tried: None when it did not install,
+ // otherwise what verification said. Decides the reason below.
+ let mut outcomes: Vec> = Vec::new();
+ // Whether the bundled torch was moved aside, so a failure can
+ // put exactly it back (#731).
+ let mut swapped = false;
+ // A re-run (a new app version) on a CUDA build that already
+ // works has nothing to install.
+ let already = verify_cuda_torch(&python) == CudaVerify::Verified;
+ if already {
+ append_to_setup_log(&data_dir, "CUDA torch already installed and verified");
+ cuda_verified = true;
+ }
+ for tag in candidates.iter().filter(|_| !already) {
append_to_setup_log(
&data_dir,
&format!(
@@ -1967,13 +2003,41 @@ fn ensure_torch_device(
torch_version_for_tag(tag)
),
);
+ // Each build goes into clean directories. The first moves
+ // the bundled torch aside; later ones clear the build
+ // before them, so no build is laid over another.
+ if let Some(site) = &site {
+ if !swapped {
+ match torchswap::snapshot(site) {
+ Ok(n) => {
+ swapped = true;
+ append_to_setup_log(
+ &data_dir,
+ &format!("moved the bundled torch aside ({n} entries)"),
+ );
+ }
+ Err(e) => append_to_setup_log(
+ &data_dir,
+ &format!("could not move the bundled torch aside ({e}); installing over it"),
+ ),
+ }
+ } else if let Err(e) = torchswap::discard_installed(site) {
+ append_to_setup_log(
+ &data_dir,
+ &format!("could not clear the previous CUDA build ({e})"),
+ );
+ }
+ }
let index_url = format!("https://download.pytorch.org/whl/{tag}");
if let Err(e) = install_cuda_torch(&python, &index_url, &state, &app) {
append_to_setup_log(&data_dir, &format!("{tag} install failed: {e}"));
+ outcomes.push(None);
continue;
}
cuda_installed = true;
- if verify_cuda_torch(&python) {
+ let outcome = verify_cuda_torch(&python);
+ outcomes.push(Some(outcome));
+ if outcome == CudaVerify::Verified {
append_to_setup_log(&data_dir, &format!("{tag} verified"));
cuda_verified = true;
break;
@@ -1981,19 +2045,32 @@ fn ensure_torch_device(
append_to_setup_log(&data_dir, &format!("{tag} installed but did not verify"));
}
let reason = if cuda_verified {
+ if swapped {
+ if let Some(site) = &site {
+ if let Err(e) = torchswap::commit(site) {
+ append_to_setup_log(
+ &data_dir,
+ &format!("could not delete the torch backup ({e})"),
+ );
+ }
+ }
+ }
"verified"
} else {
// CUDA torch is installed but unusable. Falling back to the
// "cpu" device is not enough — app/main.py imports torch at
// module scope, so a wheel that cannot load keeps the
// backend from starting at all. Put the CPU wheels back
- // (#324).
- let stage = if cuda_installed {
- "cuda-verify-failed"
- } else {
- "cuda-install-failed"
- };
- match restore_cpu_torch(&python, &state, &app) {
+ // (#324), and check they import (#731).
+ let stage = cuda_failure_stage(&outcomes);
+ match put_cpu_torch_back(
+ &python,
+ site.as_deref(),
+ swapped,
+ &state,
+ &app,
+ &data_dir,
+ ) {
Ok(()) => stage,
Err(e) => {
append_to_setup_log(
@@ -2325,13 +2402,23 @@ fn wheel_tag(compute_cap: Option<&str>, cuda_version: &str) -> &'static str {
/// on the GPU and then fail at separation time.
#[cfg(any(not(target_os = "macos"), test))]
fn wheel_candidates(compute_cap: Option<&str>, cuda_version: &str) -> Vec<&'static str> {
- let blackwell = compute_cap
- .and_then(|cap| cap.split('.').next()?.parse::().ok())
- .is_some_and(|major| major >= 10);
+ let cap_major = compute_cap.and_then(|cap| cap.split('.').next()?.parse::().ok());
+ let blackwell = cap_major.is_some_and(|major| major >= 10);
if blackwell {
return vec!["cu128"];
}
+ // torch 2.8 (cu128) dropped Maxwell and Pascal: its Windows builds start
+ // at sm_61 and its Linux builds at sm_70 (TORCH_CUDA_ARCH_LIST in
+ // pytorch's release/2.8 .ci scripts). The 2.6 line keeps sm_50 in both
+ // cu124 and cu118, and an sm_50 binary runs on any 5.x card. A GTX 970
+ // under a CUDA 13 driver was offered cu128 alone, failed verification with
+ // "no kernel image is available", and dropped to CPU (#732).
+ let pre_volta = cap_major.is_some_and(|major| major < 7);
match cuda_tag(cuda_version) {
+ "cu128" if pre_volta => vec!["cu124", "cu118"],
+ // A CUDA 13 driver runs the 2.6 builds too, so they are a second
+ // chance when cu128 installs but does not verify.
+ "cu128" => vec!["cu128", "cu124", "cu118"],
// cu118 as a second chance for a CUDA 12 driver. cu124 is the right
// first answer for all of them (see cuda_tag), but minor-version
// compatibility is the thing being relied on there, and when it does
@@ -2912,6 +2999,99 @@ fn restore_cpu_torch(
)
}
+/// The site-packages this Python installs into, asked of the interpreter
+/// itself rather than assumed from the layout, which differs between the
+/// Windows and Linux bundles and the downloaded runtime pack.
+#[cfg(not(target_os = "macos"))]
+fn torch_site_packages(python: &Path) -> Option {
+ let mut command = Command::new(python);
+ command
+ .args([
+ "-c",
+ "import sysconfig; print(sysconfig.get_paths()['purelib'])",
+ ])
+ .stdout(Stdio::piped())
+ .stderr(Stdio::null());
+ hide_console_window(&mut command);
+ let out = command_output_with_timeout(command, Duration::from_secs(60), "site-packages probe")
+ .ok()
+ .filter(|out| out.status.success())?;
+ let path = PathBuf::from(String::from_utf8_lossy(&out.stdout).trim());
+ path.is_dir().then_some(path)
+}
+
+/// Whether `import torch` works. A restore that leaves torch unimportable is
+/// a failed restore, whatever pip said (#731).
+#[cfg(not(target_os = "macos"))]
+fn verify_torch_imports(python: &Path) -> Result<(), String> {
+ let mut command = Command::new(python);
+ command
+ .args(["-c", "import torch"])
+ .stdout(Stdio::null())
+ .stderr(Stdio::piped());
+ hide_console_window(&mut command);
+ let out = command_output_with_timeout(command, GPU_VERIFY_TIMEOUT, "torch import check")?;
+ if out.status.success() {
+ return Ok(());
+ }
+ let stderr = String::from_utf8_lossy(&out.stderr);
+ let tail: Vec<&str> = stderr.trim().lines().rev().take(3).collect();
+ Err(tail.into_iter().rev().collect::>().join("\n"))
+}
+
+/// Put CPU torch back after CUDA did not work out, and prove it imports.
+///
+/// With the bundled torch moved aside, that is a rename back: exact, and no
+/// network. Without one (the move failed, or the install broke before this
+/// fix existed and has no backup), the CPU wheels are reinstalled, and if
+/// torch still cannot import, everything torch owns is deleted and they are
+/// installed once more into clean directories. That second pass is what
+/// repairs an install already carrying a stray CUDA DLL (#723).
+#[cfg(not(target_os = "macos"))]
+fn put_cpu_torch_back(
+ python: &Path,
+ site: Option<&Path>,
+ swapped: bool,
+ state: &BackendState,
+ app: &tauri::AppHandle,
+ data_dir: &Path,
+) -> Result<(), String> {
+ if let (true, Some(site)) = (swapped, site) {
+ match torchswap::restore(site) {
+ Ok(()) => match verify_torch_imports(python) {
+ Ok(()) => {
+ append_to_setup_log(data_dir, "put the bundled torch back");
+ return Ok(());
+ }
+ Err(e) => append_to_setup_log(
+ data_dir,
+ &format!("the restored torch does not import:\n{e}"),
+ ),
+ },
+ Err(e) => append_to_setup_log(
+ data_dir,
+ &format!("could not put the bundled torch back ({e})"),
+ ),
+ }
+ }
+ restore_cpu_torch(python, state, app)?;
+ let Err(first) = verify_torch_imports(python) else {
+ return Ok(());
+ };
+ append_to_setup_log(
+ data_dir,
+ &format!("CPU torch reinstalled over the old files but does not import:\n{first}"),
+ );
+ let site = site.ok_or("torch does not import and site-packages is unknown")?;
+ torchswap::discard_installed(site)
+ .map_err(|e| format!("could not clear the broken torch ({e})"))?;
+ restore_cpu_torch(python, state, app)?;
+ verify_torch_imports(python)
+ .map_err(|e| format!("CPU torch does not import after a clean reinstall:\n{e}"))?;
+ append_to_setup_log(data_dir, "CPU torch reinstalled into clean directories");
+ Ok(())
+}
+
#[cfg(not(target_os = "macos"))]
fn install_cuda_torch(
python: &Path,
@@ -2919,11 +3099,9 @@ fn install_cuda_torch(
state: &BackendState,
app: &tauri::AppHandle,
) -> Result<(), String> {
- // Skip only when CUDA torch is already active — torch.version.cuda is
- // None for CPU-only wheels, so this correctly re-installs when needed.
- if verify_cuda_torch(python) {
- return Ok(());
- }
+ // Whether a working CUDA build is already installed is decided once, by
+ // the caller, before any build is moved aside: asked here, after the
+ // bundled torch has been moved, it would always say no.
// Fix the build machine's Python path baked into pyvenv.cfg before pip
// runs — pip validates the `home` entry and fails if it doesn't exist.
@@ -3015,8 +3193,49 @@ fn cuda_install_passes<'a>(
/// an unbounded wait is an unbounded hang (#502).
const GPU_VERIFY_TIMEOUT: Duration = Duration::from_secs(120);
+/// What a CUDA verification run showed.
+#[cfg(any(not(target_os = "macos"), test))]
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+enum CudaVerify {
+ Verified,
+ /// The build has no kernels for this GPU. Another build might, but trying
+ /// the same builds again on the next launch never will (#733).
+ NoKernelImage,
+ /// Anything else, including a timeout. Worth retrying next launch.
+ Failed,
+}
+
+/// Whether a failed verification was the "this build has no kernels for your
+/// GPU" error. Matched on CUDA's exact wording, because a looser match would
+/// settle a driver or install problem as permanent.
+#[cfg(any(not(target_os = "macos"), test))]
+fn is_no_kernel_image(stderr: &str) -> bool {
+ stderr.contains("no kernel image is available for execution on the device")
+}
+
+/// The reason recorded when CUDA setup does not end on the GPU.
+///
+/// `cuda-unsupported-gpu` means every build that installed was refused for
+/// having no kernels for this card, and nothing else went wrong. The setup
+/// screen treats it as settled, so the same builds are not downloaded and
+/// refused again on every launch (#733). A new app version re-runs setup
+/// anyway, which is when different builds could be on offer.
+#[cfg(any(not(target_os = "macos"), test))]
+fn cuda_failure_stage(outcomes: &[Option]) -> &'static str {
+ let installed: Vec = outcomes.iter().flatten().copied().collect();
+ if installed.is_empty() {
+ "cuda-install-failed"
+ } else if installed.len() == outcomes.len()
+ && installed.iter().all(|o| *o == CudaVerify::NoKernelImage)
+ {
+ "cuda-unsupported-gpu"
+ } else {
+ "cuda-verify-failed"
+ }
+}
+
#[cfg(not(target_os = "macos"))]
-fn verify_cuda_torch(python: &Path) -> bool {
+fn verify_cuda_torch(python: &Path) -> CudaVerify {
// Don't trust torch.cuda.is_available() alone: it returns True even when the
// installed wheel has no kernels for the device (e.g. sm_120 on a cu124
// build), which then crashes mid-extraction with "no kernel image is
@@ -3050,7 +3269,7 @@ fn verify_cuda_torch(python: &Path) -> bool {
};
match command_output_with_timeout(command, GPU_VERIFY_TIMEOUT, "CUDA verify") {
- Ok(out) if out.status.success() => true,
+ Ok(out) if out.status.success() => CudaVerify::Verified,
Ok(out) => {
let stderr = String::from_utf8_lossy(&out.stderr);
if !stderr.trim().is_empty() {
@@ -3060,7 +3279,11 @@ fn verify_cuda_torch(python: &Path) -> bool {
// torch loaded but reported no usable device.
log("CUDA verify failed: torch reported no usable CUDA device");
}
- false
+ if is_no_kernel_image(&stderr) {
+ CudaVerify::NoKernelImage
+ } else {
+ CudaVerify::Failed
+ }
}
Err(e) => {
// The timeout path lands here, and it is the one worth naming
@@ -3071,7 +3294,7 @@ fn verify_cuda_torch(python: &Path) -> bool {
and falling back to CPU. A driver that does not match the installed \
CUDA wheel is the usual cause."
));
- false
+ CudaVerify::Failed
}
}
}
@@ -6211,6 +6434,84 @@ mod tests {
assert_eq!(super::wheel_candidates(None, "11.8"), vec!["cu118"]);
}
+ /// The reporter's GTX 970 (sm_52) under a CUDA 13 driver (#723, #732).
+ /// torch 2.8's cu128 builds have no kernels below sm_61 on Windows or
+ /// sm_70 on Linux, so every pre-Volta card goes to the 2.6 builds.
+ #[cfg(not(target_os = "macos"))]
+ #[test]
+ fn a_pre_volta_card_is_never_offered_cu128() {
+ for cap in ["5.0", "5.2", "6.0", "6.1", "6.2"] {
+ for driver in ["13.0", "12.8", "12.4", "11.8"] {
+ let tags = super::wheel_candidates(Some(cap), driver);
+ assert!(
+ !tags.is_empty(),
+ "cap {cap}, driver {driver}: nothing offered"
+ );
+ assert!(
+ !tags.contains(&"cu128"),
+ "cap {cap}, driver {driver}: offered {tags:?}"
+ );
+ }
+ }
+ assert_eq!(
+ super::wheel_candidates(Some("5.2"), "13.0"),
+ vec!["cu124", "cu118"]
+ );
+ }
+
+ /// The reporter's setup log: the GPU was refused by every build for having
+ /// no kernels, and setup repeated the whole install on each of six
+ /// launches (#733). That outcome, and only that one, is settled.
+ #[test]
+ fn a_gpu_every_build_refuses_is_settled_as_unsupported() {
+ use super::CudaVerify::{Failed, NoKernelImage, Verified};
+ let stage = super::cuda_failure_stage;
+ assert_eq!(stage(&[Some(NoKernelImage)]), "cuda-unsupported-gpu");
+ assert_eq!(
+ stage(&[Some(NoKernelImage), Some(NoKernelImage)]),
+ "cuda-unsupported-gpu"
+ );
+ // Anything that might go differently next time is not settled.
+ assert_eq!(
+ stage(&[Some(NoKernelImage), Some(Failed)]),
+ "cuda-verify-failed"
+ );
+ assert_eq!(stage(&[Some(NoKernelImage), None]), "cuda-verify-failed");
+ assert_eq!(stage(&[Some(Failed)]), "cuda-verify-failed");
+ assert_eq!(stage(&[None, None]), "cuda-install-failed");
+ assert_eq!(stage(&[]), "cuda-install-failed");
+ // Verified never reaches here, but must not read as unsupported.
+ assert_eq!(stage(&[Some(Verified)]), "cuda-verify-failed");
+ }
+
+ #[test]
+ fn only_cudas_own_wording_counts_as_no_kernel_image() {
+ // The line from the reporter's setup.log.
+ assert!(super::is_no_kernel_image(
+ "torch.AcceleratorError: CUDA error: no kernel image is available for execution on the device"
+ ));
+ assert!(!super::is_no_kernel_image("CUDA error: out of memory"));
+ assert!(!super::is_no_kernel_image(
+ "RuntimeError: CUDA kernel launch timed out"
+ ));
+ assert!(!super::is_no_kernel_image(""));
+ }
+
+ /// A card cu128 does support still starts there, with the 2.6 builds
+ /// behind it instead of CPU.
+ #[cfg(not(target_os = "macos"))]
+ #[test]
+ fn a_cuda_13_driver_falls_back_to_the_2_6_builds() {
+ assert_eq!(
+ super::wheel_candidates(Some("8.6"), "13.0"),
+ vec!["cu128", "cu124", "cu118"]
+ );
+ assert_eq!(
+ super::wheel_candidates(None, "13.0"),
+ vec!["cu128", "cu124", "cu118"]
+ );
+ }
+
/// Every wheel tag setup can offer publishes the torch line it installs.
///
/// The tag comes from the driver and the version from a table, and nothing
@@ -6234,6 +6535,8 @@ mod tests {
];
let caps = [
None,
+ Some("5.2"),
+ Some("6.1"),
Some("7.5"),
Some("8.6"),
Some("8.9"),
diff --git a/desktop/src-tauri/src/torchswap.rs b/desktop/src-tauri/src/torchswap.rs
new file mode 100644
index 00000000..522ca625
--- /dev/null
+++ b/desktop/src-tauri/src/torchswap.rs
@@ -0,0 +1,444 @@
+//! Swapping the bundled torch for a CUDA build, and back, without leftovers.
+//!
+//! The CUDA install used to lay the CUDA wheels over the CPU ones with
+//! `pip install --ignore-installed`, and the restore laid the CPU wheels back
+//! over those. Overlaying replaces shared files but never removes files only
+//! the CUDA wheel has. On Windows torch loads every DLL in `torch/lib`, so a
+//! leftover `c10_cuda.dll` from one torch version failed to link against the
+//! restored CPU DLLs from another, and `import torch` raised WinError 127 for
+//! good (#731, reported in #723).
+//!
+//! So the torch the bundle shipped is moved aside before the first CUDA
+//! install, each candidate goes into clean directories, and a failed attempt
+//! is rolled back by deleting what was installed and moving the originals
+//! back: exact, and with no network.
+//!
+//! What belongs to torch is read from pip's own `RECORD` files, never guessed
+//! from names, so nothing else in site-packages is ever touched.
+
+use std::collections::BTreeSet;
+use std::fs;
+use std::io::{self, Write};
+use std::path::{Path, PathBuf};
+
+/// The distributions a CUDA install replaces.
+const PACKAGES: [&str; 3] = ["torch", "torchaudio", "torchvision"];
+/// Next to site-packages, so moving into it is a rename on the same volume.
+const BACKUP_DIR: &str = ".stemdeck-torch-backup";
+/// Written, and flushed to disk, before anything is moved.
+const MANIFEST: &str = "manifest.txt";
+
+/// Where the backup for this site-packages lives.
+pub fn backup_root(site: &Path) -> PathBuf {
+ site.parent().unwrap_or(site).join(BACKUP_DIR)
+}
+
+/// Whether a swap was started and not finished: a crash, a forced quit, or a
+/// rollback that did not complete.
+pub fn has_backup(site: &Path) -> bool {
+ backup_root(site).join(MANIFEST).is_file()
+}
+
+/// Whether a dist-info directory name belongs to one of the torch packages.
+fn is_torch_dist_info(name: &str) -> bool {
+ let Some(stem) = name.strip_suffix(".dist-info") else {
+ return false;
+ };
+ let Some((dist, _version)) = stem.split_once('-') else {
+ return false;
+ };
+ PACKAGES.iter().any(|p| p.eq_ignore_ascii_case(dist))
+}
+
+/// The top-level names in `site` that the installed torch packages own: their
+/// dist-info directories and the first path segment of every file listed in
+/// their RECORD. Only names that exist are returned.
+pub fn owned_entries(site: &Path) -> io::Result> {
+ let mut owned = BTreeSet::new();
+ for entry in fs::read_dir(site)? {
+ let entry = entry?;
+ let name = entry.file_name().to_string_lossy().into_owned();
+ if !is_torch_dist_info(&name) {
+ continue;
+ }
+ owned.insert(name.clone());
+ match fs::read_to_string(entry.path().join("RECORD")) {
+ Ok(record) => {
+ for line in record.lines() {
+ let path = line.split(',').next().unwrap_or("").trim();
+ let first = path.split(['/', '\\']).next().unwrap_or("");
+ // "../../Scripts/torchrun.exe" and the like live outside
+ // site-packages; they are replaced in place and harmless.
+ if first.is_empty() || first == "." || first == ".." {
+ continue;
+ }
+ owned.insert(first.to_string());
+ }
+ }
+ // A damaged install with no RECORD still owns its package dir.
+ Err(_) => {
+ if let Some((dist, _)) = name.trim_end_matches(".dist-info").split_once('-') {
+ owned.insert(dist.to_lowercase());
+ }
+ }
+ }
+ }
+ owned.retain(|name| name != BACKUP_DIR && site.join(name).exists());
+ Ok(owned)
+}
+
+fn remove_entry(path: &Path) -> io::Result<()> {
+ if path.is_dir() {
+ fs::remove_dir_all(path)
+ } else if path.exists() {
+ fs::remove_file(path)
+ } else {
+ Ok(())
+ }
+}
+
+/// Move the installed torch packages aside. Fails without moving anything if
+/// there is no torch to move or a backup already exists.
+pub fn snapshot(site: &Path) -> io::Result {
+ let backup = backup_root(site);
+ if has_backup(site) {
+ return Err(io::Error::new(
+ io::ErrorKind::AlreadyExists,
+ "a torch backup already exists; restore it first",
+ ));
+ }
+ let entries = owned_entries(site)?;
+ if entries.is_empty() {
+ return Err(io::Error::new(
+ io::ErrorKind::NotFound,
+ "no torch packages found to back up",
+ ));
+ }
+ fs::create_dir_all(&backup)?;
+ // The manifest goes first and reaches the disk before anything moves, so
+ // a crash part way through leaves a record of what to put back.
+ let mut manifest = fs::File::create(backup.join(MANIFEST))?;
+ for name in &entries {
+ writeln!(manifest, "{name}")?;
+ }
+ manifest.sync_all()?;
+ drop(manifest);
+ for name in &entries {
+ fs::rename(site.join(name), backup.join(name))?;
+ }
+ Ok(entries.len())
+}
+
+/// Delete whatever torch packages are installed now. Used between candidates,
+/// so one CUDA build is never laid over another.
+pub fn discard_installed(site: &Path) -> io::Result<()> {
+ for name in owned_entries(site)? {
+ remove_entry(&site.join(name))?;
+ }
+ Ok(())
+}
+
+/// Put the backed-up torch back exactly, removing anything installed since.
+/// Safe to run after a crash at any point in `snapshot` or in itself.
+pub fn restore(site: &Path) -> io::Result<()> {
+ let backup = backup_root(site);
+ let Ok(manifest) = fs::read_to_string(backup.join(MANIFEST)) else {
+ return Ok(());
+ };
+ let names: BTreeSet = manifest
+ .lines()
+ .map(str::trim)
+ .filter(|n| !n.is_empty() && *n != "." && *n != ".." && !n.contains(['/', '\\']))
+ .map(str::to_string)
+ .collect();
+ // Moved names come back, replacing whatever is there now. A name the
+ // manifest lists but the backup lacks was never moved, so it is still the
+ // original and stays.
+ for name in &names {
+ let saved = backup.join(name);
+ if !saved.exists() {
+ continue;
+ }
+ remove_entry(&site.join(name))?;
+ fs::rename(&saved, site.join(name))?;
+ }
+ // Then anything torch-owned that the original did not have: the CUDA
+ // build's own dist-info, its extra top-level packages.
+ for name in owned_entries(site)? {
+ if !names.contains(&name) {
+ remove_entry(&site.join(name))?;
+ }
+ }
+ fs::remove_dir_all(&backup)
+}
+
+/// The swap worked: the backup is no longer needed.
+pub fn commit(site: &Path) -> io::Result<()> {
+ let backup = backup_root(site);
+ if backup.exists() {
+ fs::remove_dir_all(backup)?;
+ }
+ Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ fn tree_hashes(root: &Path) -> std::collections::BTreeMap> {
+ use sha2::{Digest, Sha256};
+ let mut out = std::collections::BTreeMap::new();
+ let mut stack = vec![root.to_path_buf()];
+ while let Some(dir) = stack.pop() {
+ for entry in fs::read_dir(&dir).unwrap() {
+ let path = entry.unwrap().path();
+ if path.is_dir() {
+ stack.push(path);
+ } else {
+ let digest = Sha256::digest(fs::read(&path).unwrap()).to_vec();
+ out.insert(path.strip_prefix(root).unwrap().to_path_buf(), digest);
+ }
+ }
+ }
+ out
+ }
+
+ fn copy_tree(from: &Path, to: &Path) {
+ if from.is_dir() {
+ fs::create_dir_all(to).unwrap();
+ for entry in fs::read_dir(from).unwrap() {
+ let entry = entry.unwrap();
+ copy_tree(&entry.path(), &to.join(entry.file_name()));
+ }
+ } else {
+ fs::copy(from, to).unwrap();
+ }
+ }
+
+ /// The rollback on a real torch install rather than a fake one: gigabytes,
+ /// thousands of files, real RECORDs. Run by hand, with a site-packages to
+ /// copy from and a folder to work in (left behind, so the result can be
+ /// imported afterwards):
+ ///
+ /// STEMDECK_REAL_TORCH_SITE= STEMDECK_REAL_TORCH_WORK=
+ /// cargo test real_torch -- --ignored
+ #[test]
+ #[ignore]
+ fn a_real_torch_comes_back_byte_for_byte() {
+ let (Ok(source), Ok(work)) = (
+ std::env::var("STEMDECK_REAL_TORCH_SITE"),
+ std::env::var("STEMDECK_REAL_TORCH_WORK"),
+ ) else {
+ panic!("set STEMDECK_REAL_TORCH_SITE and STEMDECK_REAL_TORCH_WORK");
+ };
+ let source = PathBuf::from(source);
+ let site = PathBuf::from(work).join("Lib").join("site-packages");
+ if site.exists() {
+ fs::remove_dir_all(&site).unwrap();
+ }
+ let _ = fs::remove_dir_all(backup_root(&site));
+ fs::create_dir_all(&site).unwrap();
+ let owned = owned_entries(&source).unwrap();
+ assert!(owned.contains("torch"), "no torch in {}", source.display());
+ for name in &owned {
+ copy_tree(&source.join(name), &site.join(name));
+ }
+ let before = tree_hashes(&site);
+
+ let moved = snapshot(&site).unwrap();
+ assert_eq!(moved, owned.len());
+ // A CUDA build laid into the clean directories, with a DLL the CPU
+ // build does not have.
+ let lib = site.join("torch").join("lib");
+ fs::create_dir_all(&lib).unwrap();
+ fs::write(lib.join("c10_cuda.dll"), "cuda").unwrap();
+ fs::write(lib.join("c10.dll"), "cuda c10").unwrap();
+ let dist = site.join("torch-2.8.0+cu128.dist-info");
+ fs::create_dir_all(&dist).unwrap();
+ fs::write(
+ dist.join("RECORD"),
+ "torch/lib/c10.dll,,\ntorch/lib/c10_cuda.dll,,\ntorch-2.8.0+cu128.dist-info/RECORD,,\n",
+ )
+ .unwrap();
+
+ restore(&site).unwrap();
+
+ assert_eq!(
+ tree_hashes(&site),
+ before,
+ "the restored torch differs from the original"
+ );
+ assert!(!has_backup(&site));
+ }
+
+ /// A site-packages with torch as pip lays it out, plus a neighbour that
+ /// must never be touched.
+ fn fake_site(root: &Path, version: &str, extra_lib: Option<&str>) -> PathBuf {
+ let site = root.join("Lib").join("site-packages");
+ let lib = site.join("torch").join("lib");
+ fs::create_dir_all(&lib).unwrap();
+ fs::write(lib.join("c10.dll"), format!("c10 {version}")).unwrap();
+ let mut record = String::from("torch/lib/c10.dll,,\n");
+ // A leftover from an earlier overlay: on disk, but in no RECORD,
+ // exactly as the reporter's c10_cuda.dll was.
+ if let Some(dll) = extra_lib {
+ fs::write(lib.join(dll), "cuda").unwrap();
+ }
+ fs::create_dir_all(site.join("functorch")).unwrap();
+ fs::write(site.join("functorch").join("__init__.py"), version).unwrap();
+ record.push_str("functorch/__init__.py,,\n../../Scripts/torchrun.exe,,\n");
+ let dist = site.join(format!("torch-{version}.dist-info"));
+ fs::create_dir_all(&dist).unwrap();
+ record.push_str(&format!("torch-{version}.dist-info/RECORD,,\n"));
+ fs::write(dist.join("RECORD"), record).unwrap();
+ fs::create_dir_all(site.join("numpy")).unwrap();
+ fs::write(site.join("numpy").join("__init__.py"), "numpy").unwrap();
+ site
+ }
+
+ /// Lay a CUDA torch into `site` the way pip would into clean directories.
+ fn install_cuda(site: &Path) {
+ let lib = site.join("torch").join("lib");
+ fs::create_dir_all(&lib).unwrap();
+ fs::write(lib.join("c10.dll"), "c10 cuda").unwrap();
+ fs::write(lib.join("c10_cuda.dll"), "cuda").unwrap();
+ let dist = site.join("torch-2.6.0+cu124.dist-info");
+ fs::create_dir_all(&dist).unwrap();
+ fs::write(
+ dist.join("RECORD"),
+ "torch/lib/c10.dll,,\ntorch/lib/c10_cuda.dll,,\ntorch-2.6.0+cu124.dist-info/RECORD,,\n",
+ )
+ .unwrap();
+ }
+
+ #[test]
+ fn owned_entries_come_from_record_and_leave_neighbours_alone() {
+ let tmp = tempfile::tempdir().unwrap();
+ let site = fake_site(tmp.path(), "2.6.0+cpu", None);
+ let owned = owned_entries(&site).unwrap();
+ assert!(owned.contains("torch"));
+ assert!(owned.contains("functorch"));
+ assert!(owned.contains("torch-2.6.0+cpu.dist-info"));
+ assert!(!owned.contains("numpy"));
+ assert!(!owned.contains(".."));
+ }
+
+ /// The #723 install: rolling back must leave no c10_cuda.dll behind, and
+ /// the original c10.dll byte for byte.
+ #[test]
+ fn a_rollback_leaves_no_cuda_dll_behind() {
+ let tmp = tempfile::tempdir().unwrap();
+ let site = fake_site(tmp.path(), "2.6.0+cpu", None);
+ snapshot(&site).unwrap();
+ assert!(
+ !site.join("torch").exists(),
+ "the original was not moved aside"
+ );
+ install_cuda(&site);
+
+ restore(&site).unwrap();
+
+ let lib = site.join("torch").join("lib");
+ assert!(!lib.join("c10_cuda.dll").exists());
+ assert_eq!(
+ fs::read_to_string(lib.join("c10.dll")).unwrap(),
+ "c10 2.6.0+cpu"
+ );
+ assert!(site.join("torch-2.6.0+cpu.dist-info").exists());
+ assert!(!site.join("torch-2.6.0+cu124.dist-info").exists());
+ assert_eq!(
+ fs::read_to_string(site.join("numpy").join("__init__.py")).unwrap(),
+ "numpy"
+ );
+ assert!(!has_backup(&site));
+ }
+
+ #[test]
+ fn a_second_candidate_installs_into_clean_directories() {
+ let tmp = tempfile::tempdir().unwrap();
+ let site = fake_site(tmp.path(), "2.6.0+cpu", None);
+ snapshot(&site).unwrap();
+ install_cuda(&site);
+ discard_installed(&site).unwrap();
+ assert!(!site.join("torch").exists());
+ assert!(!site.join("torch-2.6.0+cu124.dist-info").exists());
+ assert!(site.join("numpy").exists());
+ assert!(
+ has_backup(&site),
+ "the original must survive between candidates"
+ );
+ }
+
+ #[test]
+ fn a_verified_swap_drops_the_backup() {
+ let tmp = tempfile::tempdir().unwrap();
+ let site = fake_site(tmp.path(), "2.6.0+cpu", None);
+ snapshot(&site).unwrap();
+ install_cuda(&site);
+ commit(&site).unwrap();
+ assert!(!has_backup(&site));
+ assert!(site.join("torch").join("lib").join("c10_cuda.dll").exists());
+ }
+
+ /// A crash part way through the snapshot: some entries moved, some not.
+ /// Restoring puts back what moved and keeps what never did.
+ #[test]
+ fn a_snapshot_interrupted_part_way_is_recovered() {
+ let tmp = tempfile::tempdir().unwrap();
+ let site = fake_site(tmp.path(), "2.6.0+cpu", None);
+ let backup = backup_root(&site);
+ fs::create_dir_all(&backup).unwrap();
+ let entries = owned_entries(&site).unwrap();
+ let listed: Vec<&String> = entries.iter().collect();
+ fs::write(
+ backup.join(MANIFEST),
+ listed.iter().map(|n| format!("{n}\n")).collect::(),
+ )
+ .unwrap();
+ fs::rename(site.join(listed[0]), backup.join(listed[0])).unwrap();
+
+ assert!(has_backup(&site));
+ restore(&site).unwrap();
+
+ assert_eq!(owned_entries(&site).unwrap(), entries);
+ assert_eq!(
+ fs::read_to_string(site.join("torch").join("lib").join("c10.dll")).unwrap(),
+ "c10 2.6.0+cpu"
+ );
+ assert!(!has_backup(&site));
+ }
+
+ #[test]
+ fn a_second_snapshot_refuses_rather_than_overwrite_the_first() {
+ let tmp = tempfile::tempdir().unwrap();
+ let site = fake_site(tmp.path(), "2.6.0+cpu", None);
+ snapshot(&site).unwrap();
+ install_cuda(&site);
+ assert!(snapshot(&site).is_err());
+ restore(&site).unwrap();
+ assert_eq!(
+ fs::read_to_string(site.join("torch").join("lib").join("c10.dll")).unwrap(),
+ "c10 2.6.0+cpu"
+ );
+ }
+
+ #[test]
+ fn nothing_to_restore_is_not_an_error() {
+ let tmp = tempfile::tempdir().unwrap();
+ let site = fake_site(tmp.path(), "2.6.0+cpu", None);
+ restore(&site).unwrap();
+ assert!(site.join("torch").exists());
+ }
+
+ /// An install that already has the leftover DLL (the reporter's state)
+ /// is cleared entirely by discard_installed, ahead of a clean reinstall.
+ #[test]
+ fn a_broken_install_is_cleared_before_reinstalling() {
+ let tmp = tempfile::tempdir().unwrap();
+ let site = fake_site(tmp.path(), "2.6.0+cpu", Some("c10_cuda.dll"));
+ discard_installed(&site).unwrap();
+ assert!(!site.join("torch").exists());
+ assert!(!site.join("functorch").exists());
+ assert!(site.join("numpy").exists());
+ }
+}
diff --git a/desktop/src-tauri/tauri.conf.json b/desktop/src-tauri/tauri.conf.json
index 5604ffd7..8ad86950 100644
--- a/desktop/src-tauri/tauri.conf.json
+++ b/desktop/src-tauri/tauri.conf.json
@@ -24,7 +24,7 @@
}
],
"security": {
- "csp": "default-src 'self'; script-src 'self'; style-src 'self' 'unsafe-inline' https://fonts.googleapis.com; font-src 'self' https://fonts.gstatic.com data:; img-src 'self' data: blob:; connect-src 'self' ipc: http://ipc.localhost; object-src 'none'; base-uri 'self'; frame-ancestors 'none'"
+ "csp": "default-src 'self'; script-src 'self' 'wasm-unsafe-eval'; style-src 'self' 'unsafe-inline' https://fonts.googleapis.com; font-src 'self' https://fonts.gstatic.com data:; img-src 'self' data: blob:; connect-src 'self' ipc: http://ipc.localhost; object-src 'none'; base-uri 'self'; frame-ancestors 'none'"
}
},
"bundle": {
diff --git a/desktop/ui/setup.js b/desktop/ui/setup.js
index 3a0bb557..fed8146b 100644
--- a/desktop/ui/setup.js
+++ b/desktop/ui/setup.js
@@ -322,10 +322,17 @@ async function runSetup() {
// that predates reason tracking -- re-runs the GPU step on this launch, so
// a single bad first run can't pin the install to CPU forever (#247).
// Cost when nothing changed: one fast nvidia-smi probe.
+ //
+ // A GPU that every offered CUDA build refused for having no kernels for it
+ // is settled too: trying the same builds again cannot go differently, and
+ // did cost about 45 s of download and install on every launch (#733). A
+ // new version re-runs setup through versionMismatch below, which is when
+ // different builds could be on offer.
const torchDeviceSettled =
runtime.torchDevice === "cuda" ||
runtime.torchDevice === "mps" ||
- (runtime.torchDevice === "cpu" && runtime.torchDeviceReason === "cpu-only-package");
+ (runtime.torchDevice === "cpu" && runtime.torchDeviceReason === "cpu-only-package") ||
+ (runtime.torchDevice === "cpu" && runtime.torchDeviceReason === "cuda-unsupported-gpu");
if (runtime.pythonReady && runtime.ffmpegReady && torchDeviceSettled && !versionMismatch) {
for (const step of steps) {
@@ -449,7 +456,11 @@ async function runSetup() {
? `${gpu.gpuName} acceleration enabled`
: "MPS acceleration unavailable - stem separation will use CPU";
} else {
- if (gpu.gpuDetected && !gpu.cudaVerified) {
+ if (gpu.gpuDetected && !gpu.cudaVerified && gpu.reason === "cuda-unsupported-gpu") {
+ showError(
+ `GPU detected (${gpu.gpuName}), but none of the CUDA builds StemDeck can install support it - stem separation will use CPU. StemDeck will not try again until the next update.`
+ );
+ } else if (gpu.gpuDetected && !gpu.cudaVerified) {
showError(
`GPU detected (${gpu.gpuName}) but CUDA setup failed - stem separation will use CPU.\nCheck logs/setup.log in the StemDeck data folder for details.`
);
diff --git a/static/css/daw.css b/static/css/daw.css
index 8370923a..b4527f1f 100644
--- a/static/css/daw.css
+++ b/static/css/daw.css
@@ -292,7 +292,7 @@ input, textarea { font-family: inherit; }
color: var(--color);
}
/* Automatic song-structure detection. It sits at the end of the composer next
- to Split stems and matches its footprint, so the pair reads as two segments
+ to Extract stems and matches its footprint, so the pair reads as two segments
of one bar rather than a chip loose beside a button. Colour still separates
them: the timeline blue, never the amber the primary action owns. */
.structure-toggle {
@@ -782,6 +782,7 @@ input, textarea { font-family: inherit; }
/* cat-item (legacy catalog items JS creates) */
.cat-item {
+ position: relative;
display: flex;
gap: 9px;
align-items: center;
@@ -905,14 +906,36 @@ input, textarea { font-family: inherit; }
.queue-row:hover .queue-top { opacity: 0.65; }
.queue-top:hover { background: rgba(232, 168, 56, 0.16); color: var(--accent); opacity: 1; }
.queue-top:disabled { opacity: 0.3; cursor: default; }
-.cat-del {
+/* A row's actions float over its right edge and show on hover or keyboard
+ focus (#724). In the flow they cost the title their width on every row at
+ rest, which is where titles were being cut short, and a second button in
+ the flow would have cost it again. The fade lets a long title run under
+ them instead of stopping at a hard edge. */
+.cat-actions {
+ position: absolute; top: 50%; right: 6px; transform: translateY(-50%);
+ display: flex; gap: 2px; padding-left: 16px;
+ background: linear-gradient(to right, transparent, var(--panel-2) 14px);
+ opacity: 0; pointer-events: none;
+ transition: opacity var(--t-fast);
+}
+.cat-item:hover .cat-actions,
+.cat-item:focus-within .cat-actions { opacity: 1; pointer-events: auto; }
+.cat-del, .cat-fav {
width: 20px; height: 20px; border: 0; border-radius: 5px;
background: transparent; color: var(--muted); cursor: pointer;
- opacity: 0; display: flex; align-items: center; justify-content: center;
- padding: 0; flex-shrink: 0; transition: opacity var(--t-fast), background var(--t-fast);
+ display: flex; align-items: center; justify-content: center;
+ padding: 0; flex-shrink: 0; transition: background var(--t-fast), color var(--t-fast);
}
-.cat-item:hover .cat-del { opacity: 1; }
.cat-del:hover { background: rgba(21,31,39,0.8); color: var(--danger); }
+.cat-fav:hover { background: rgba(21,31,39,0.8); color: var(--fg); }
+.cat-fav.active, .cat-fav.active:hover { color: #e54e4e; }
+/* A favourite says so at rest, in the subline, where it takes no title room. */
+.cat-item.is-fav .cat-sub::before {
+ content: ""; flex-shrink: 0; align-self: center;
+ width: 9px; height: 9px; background: #e54e4e;
+ -webkit-mask: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 24 24'%3E%3Cpath d='M20.84 4.61a5.5 5.5 0 0 0-7.78 0L12 5.67l-1.06-1.06a5.5 5.5 0 0 0-7.78 7.78l1.06 1.06L12 21.23l7.78-7.78 1.06-1.06a5.5 5.5 0 0 0 0-7.78z'/%3E%3C/svg%3E") center / contain no-repeat;
+ mask: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 24 24'%3E%3Cpath d='M20.84 4.61a5.5 5.5 0 0 0-7.78 0L12 5.67l-1.06-1.06a5.5 5.5 0 0 0-7.78 7.78l1.06 1.06L12 21.23l7.78-7.78 1.06-1.06a5.5 5.5 0 0 0 0-7.78z'/%3E%3C/svg%3E") center / contain no-repeat;
+}
/* Folder items (legacy catalog) */
.folder { display: flex; flex-direction: column; }
@@ -996,6 +1019,8 @@ input, textarea { font-family: inherit; }
.folder-editor-colors { display: flex; align-items: center; gap: 9px; }
.folder-editor-colors .folder-color-dot { width: 22px; height: 22px; }
.folder-editor-msg { color: var(--danger); font-size: 11px; margin-top: 8px; }
+/* The separation engine cannot load at all (#730). */
+.set-demucs-desc.is-broken { color: var(--danger); }
.folder-editor-msg:empty { display: none; }
.folder-editor-actions { display: flex; justify-content: flex-end; gap: 8px; margin-top: 14px; }
.folder-editor-actions button { min-height: 30px; border-radius: 7px; font-family: var(--font-mono); font-size: 11px; cursor: pointer; padding: 0 11px; }
@@ -1363,6 +1388,20 @@ input, textarea { font-family: inherit; }
grid-template-columns: repeat(7, minmax(0, 1fr));
border-bottom: 1px solid var(--border);
}
+/* Key takes the column the Scale card had (#736). "F# harmonisches Moll" has to
+ fit, and two columns keep the seven edges the presence row lines up with. */
+.daw-meta-card[data-meta="key"] { grid-column: span 2; }
+/* Even two columns are 115 px of text at a 950 px window, and "F# harmonisches
+ Moll" needs 155. Clipping it would hide the mode, which is the part the
+ label exists to say, so the key wraps instead: a short key still sits on
+ one line at any width, a long one takes two. */
+.daw-meta-card[data-meta="key"] .meta-card-main { align-items: center; }
+.daw-meta-card[data-meta="key"] .meta-card-value {
+ white-space: normal;
+ overflow-wrap: break-word;
+ line-height: 1.15;
+ text-wrap: balance;
+}
/* Track card */
.daw-track-card {
@@ -4801,19 +4840,27 @@ input, textarea { font-family: inherit; }
and are therefore exactly the same width. As a flex row the search grew to
whatever was left over, which is why it ran past the last chip.
- Columns: content | detect | split | rule | card. Row one is the import
- gesture, row two is what to extract. Split sits straight after the options
- it acts on, and the loaded track comes after the rule, at the end: in the
- middle of the row it read as Split's input, when it is only what is
- playing (#699). */
+ Columns: content | actions | panel toggles | rule | card. Row one is the
+ import gesture, row two is what to extract. The two actions stack in one
+ column, Detect structure over Extract stems, so Extract sits on the chips'
+ row, straight after the options it acts on, and the Collapse toggles stack
+ beside them (#725). Stacked rather than side by side, the right-hand end
+ is about 50px narrower, which is room the card keeps. The loaded track
+ comes after the rule, at the end: in the middle of the row it read as
+ Extract's input, when it is only what is playing (#699). */
height: auto;
display: grid;
/* minmax(0, 1fr), not 1fr: a grid track's automatic minimum is its
min-content, so a plain 1fr refuses to shrink below the widest thing in
- it. The card sat at its natural width and pushed Split stems off the right
+ it. The card sat at its natural width and pushed Extract stems off the right
edge of its own container. Zero as the floor lets the column give way, and
the card's own text clips with an ellipsis rather than forcing the row. */
- grid-template-columns: minmax(0, max-content) auto auto auto minmax(0, 1fr);
+ /* The card's floor is its compact form, the heart and the About this song
+ button and nothing else (#735). Below what the whole card needs, the
+ chips fold into their overflow button first (fitStemChips), so the card
+ is never squeezed out of the row the way display: none once took it. */
+ --np-min: 72px;
+ grid-template-columns: minmax(0, max-content) auto auto auto minmax(var(--np-min), 1fr);
align-items: center;
row-gap: 8px;
column-gap: 10px;
@@ -4964,8 +5011,13 @@ input, textarea { font-family: inherit; }
border-left: none;
}
.daw-composer > .daw-process-btn {
- grid-column: 3;
- grid-row: 1;
+ grid-column: 2;
+ grid-row: 2;
+ /* As wide as Detect structure above it, and as tall as the chips beside
+ it, so the bar keeps its height. */
+ justify-self: stretch;
+ min-height: 30px;
+ height: 30px;
}
/* 2. Ten percent off the waveform: REMOVED.
@@ -4985,31 +5037,30 @@ input, textarea { font-family: inherit; }
and it would need the strip and the footer inset to match, or something
given the freed space. */
-/* Row two, under the two actions: on the chips' line rather than below it.
+/* The Collapse toggles, a column of their own beside the two actions (#725):
+ the label on top, then one toggle per panel, spanning both rows. Beside the
+ actions rather than under them, which is what lets Extract stems take the
+ chips' row.
- Columns 2 to 4, the two action columns only, not the rule's: a spanning
- item's minimum lands in the first track it covers, and the 1px rule column
- would have been handed the toggles' whole width. The action columns are
- already as wide as Detect structure and Split stems, which is more than the
- toggles need, so spanning only those costs the row nothing.
-
- A grid item rather than absolutely positioned: out of flow it sat on the
- right line and would have landed on top of the Extract chips the moment a
- window was narrow enough for the two to meet. */
+ A grid item rather than absolutely positioned: out of flow it would land on
+ top of the Extract chips the moment a window was narrow enough for the two
+ to meet. */
.daw-composer > .daw-panel-toggles {
- grid-column: 2 / 4;
- grid-row: 2;
- justify-self: end;
+ grid-column: 3;
+ grid-row: 1 / 3;
align-self: center;
+ flex-direction: column;
+ align-items: stretch;
+ justify-content: center;
width: auto;
min-width: 0;
margin: 0;
- /* The wrapper stops being a box of its own: each toggle is a chip now, so a
+ /* The wrapper stops being a box of its own: each toggle is a chip, so a
frame around the group would be a box inside a box. */
padding: 0;
background: none;
border: none;
- gap: 6px;
+ gap: 4px;
}
/* 4. The toggles become chips, the same size as the Extract ones.
@@ -5018,7 +5069,10 @@ input, textarea { font-family: inherit; }
The colours stay theirs, including the strike-through that means a panel is
put away. */
.daw-composer-stack .daw-panel-toggle {
- height: 30px;
+ /* 26, not the chips' 30: three to a column have to fit in the height of
+ the two rows beside them. */
+ height: 26px;
+ justify-content: center;
padding: 0 11px;
border: 1px solid var(--border);
border-radius: 6px;
@@ -5036,7 +5090,8 @@ input, textarea { font-family: inherit; }
font-size: 12px;
letter-spacing: -0.005em;
text-transform: none;
- margin-right: 4px;
+ text-align: center;
+ margin: 0;
padding: 0;
border: none;
}
@@ -5091,7 +5146,7 @@ input, textarea { font-family: inherit; }
align-self: stretch;
/* .footer-track-slot is `width: var(--daw-col-w)`, which is the gutter width
it was built to fill in the footer. Here the column decides the width, so
- the fixed one has to go or the card never shrinks and pushes Split stems
+ the fixed one has to go or the card never shrinks and pushes Extract stems
out of the composer on a narrow window. */
width: auto;
min-width: 0;
@@ -5420,25 +5475,25 @@ input, textarea { font-family: inherit; }
display: none;
}
-/* Below about 1450px the two rows cannot hold everything.
- *
- * Measured rather than picked: the chips need 655px at their widest, the
- * toggles 280, Detect structure 164 and Split stems 140. With gaps and the
- * bar's own padding that is 1299px of composer before the card gets a pixel,
- * which is a window of roughly 1450 once the rail and the margins are paid
- * for.
- *
- * So the two things that were moved up here give way, in the order they can be
- * done without: the card first, since the track is also named in the library
- * and the mixer, then the toggles drop to a line of their own, which is where
- * they lived before. Nothing is lost at any width, it just stops being one
- * line.
- */
-@media (max-width: 1460px) {
- .daw-composer > #nowPlayingPanel { display: none; }
- /* The rule only divides the extraction from the card. Without the card it
- would divide the row from nothing. */
- .daw-composer > .daw-composer-sep { display: none; }
+/* A narrow card keeps what can be done from it (#735).
+
+ It used to leave the bar entirely below a 1460px window, and with it the
+ only way to open About this song. Now it gives way in steps as its column
+ narrows, which happens after the Extract chips have folded what they can:
+ first the artwork and the meta line, then the title, until only the heart
+ and the About button are left, each still a full-height segment at its
+ edge. Container queries, because how wide the card ends up depends on the
+ language as much as on the window. */
+@container (max-width: 239px) {
+ #nowPlayingPanel .track-panel-cover,
+ #nowPlayingPanel .daw-track-meta-line,
+ #nowPlayingPanel .np-artist { display: none; }
+ #nowPlayingPanel .track-panel-head { padding-left: calc(var(--np-fav) + 2px); }
+ #nowPlayingPanel .np-legend { left: calc(var(--np-fav) + 8px); }
+}
+@container (max-width: 129px) {
+ #nowPlayingPanel .track-panel-info,
+ #nowPlayingPanel .np-legend { display: none; }
}
/* The click-track options with nothing to act on.
diff --git a/static/css/variables.css b/static/css/variables.css
index e81c5cad..b5ae03f3 100644
--- a/static/css/variables.css
+++ b/static/css/variables.css
@@ -26,7 +26,7 @@
--other: #9ca3af;
/* Width shared by the composer's two end segments (Song structure and
- Split stems) so they match. See .daw-process-btn / .structure-toggle. */
+ Extract stems) so they match. See .daw-process-btn / .structure-toggle. */
--composer-action-w: 140px;
/* Accent */
diff --git a/static/index.html b/static/index.html
index 6c353e35..7baf25c0 100644
--- a/static/index.html
+++ b/static/index.html
@@ -270,7 +270,7 @@
- Split stems
+ Extract stems
@@ -452,8 +452,6 @@
`;
@@ -620,7 +629,7 @@ function extractScreen() {
-
+
${extractProgressCard()}
`;
@@ -841,6 +850,29 @@ function closeSwipe() {
closeOtherSwipes(null);
}
+// The same flag the desktop's hearts set (#734). The row changes at once and
+// goes back if the server refuses, so a tap never shows a state that was not
+// kept.
+async function toggleFavorite(id) {
+ const track = state.tracks.find((t) => t.id === id);
+ if (!track) return;
+ track.favorite = !track.favorite;
+ render();
+ try {
+ const res = await fetch(`/api/jobs/${encodeURIComponent(id)}/favorite`, {
+ method: "PUT",
+ headers: { "Content-Type": "application/json" },
+ body: JSON.stringify({ favorite: track.favorite }),
+ });
+ if (!res.ok) throw new Error(`PUT favorite -> ${res.status}`);
+ } catch (e) {
+ console.warn("[mobile] could not save the favourite:", e);
+ track.favorite = !track.favorite;
+ toast("Could not save the favourite");
+ render();
+ }
+}
+
async function deleteTrack(id) {
state.swipedTrackId = null;
try {
@@ -962,6 +994,11 @@ app.addEventListener("click", (e) => {
case "delete":
deleteTrack(t.dataset.id);
return;
+ case "favorite":
+ // The row underneath opens the track; the heart is its own button.
+ e.stopPropagation();
+ toggleFavorite(t.dataset.id);
+ return;
case "tab":
state.tab = t.dataset.tab;
break;
diff --git a/static/mobile/styles.css b/static/mobile/styles.css
index 7cae237f..817fe836 100644
--- a/static/mobile/styles.css
+++ b/static/mobile/styles.css
@@ -778,6 +778,19 @@ button {
opacity: 1;
transform: translate(-50%, 0);
}
+.track-fav {
+ flex-shrink: 0;
+ display: grid;
+ place-items: center;
+ width: 40px;
+ height: 40px;
+ margin-right: 2px;
+ border: none;
+ background: none;
+ color: #7a7a82;
+ cursor: pointer;
+}
+.track-fav.on { color: #e54e4e; }
.track-load {
flex-shrink: 0;
border: 1px solid rgba(255, 255, 255, 0.12);
diff --git a/static/vendor/signalsmith-stretch.js b/static/vendor/signalsmith-stretch.js
new file mode 100644
index 00000000..d0460010
--- /dev/null
+++ b/static/vendor/signalsmith-stretch.js
@@ -0,0 +1,53 @@
+// Signalsmith Stretch 1.3.2, the WASM core only (#729).
+//
+// From the npm package signalsmith-stretch@1.3.2, file SignalsmithStretch.mjs,
+// lines 3 to 16: the Emscripten loader with the WASM embedded. Nothing in it is
+// changed. The package's own AudioWorkletNode wrapper is left out, because it
+// stretches only buffers it owns and ignores the rate on live input, which is
+// all StemDeck has. soundtouch-processor.js drives the core directly instead.
+//
+// Loaded as its own worklet module ahead of soundtouch-processor.js. Modules in
+// one AudioWorkletGlobalScope share its global object, which is how the loader
+// reaches the processor without an import (tests load the processor as a plain
+// function body, where an import would not parse).
+//
+// Upstream: https://signalsmith-audio.co.uk/code/stretch/
+//
+// MIT License
+//
+// Copyright (c) 2022 Geraint Luff / Signalsmith Audio Ltd.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+var SignalsmithStretch = (() => {
+ var _scriptName = typeof document != 'undefined' ? document.currentScript?.src : undefined;
+
+ return (
+function(moduleArg = {}) {
+ var moduleRtn;
+
+var Module=moduleArg;var readyPromiseResolve,readyPromiseReject;var readyPromise=new Promise((resolve,reject)=>{readyPromiseResolve=resolve;readyPromiseReject=reject});var ENVIRONMENT_IS_WEB=typeof window=="object";var ENVIRONMENT_IS_WORKER=typeof WorkerGlobalScope!="undefined";var ENVIRONMENT_IS_NODE=typeof process=="object"&&typeof process.versions=="object"&&typeof process.versions.node=="string"&&process.type!="renderer";var ENVIRONMENT_IS_SHELL=!ENVIRONMENT_IS_WEB&&!ENVIRONMENT_IS_NODE&&!ENVIRONMENT_IS_WORKER;var crypto=globalThis?.crypto||{getRandomValues:array=>{for(var i=0;iDate.now()};var moduleOverrides=Object.assign({},Module);var arguments_=[];var quit_=(status,toThrow)=>{throw toThrow};var scriptDirectory="";var readAsync,readBinary;if(ENVIRONMENT_IS_SHELL){readBinary=f=>{if(typeof readbuffer=="function"){return new Uint8Array(readbuffer(f))}let data=read(f,"binary");assert(typeof data=="object");return data};readAsync=f=>new Promise((resolve,reject)=>{setTimeout(()=>resolve(readBinary(f)))});globalThis.clearTimeout??=id=>{};globalThis.setTimeout??=f=>f();arguments_=globalThis.arguments||globalThis.scriptArgs;if(typeof quit=="function"){quit_=(status,toThrow)=>{setTimeout(()=>{if(!(toThrow instanceof ExitStatus)){let toLog=toThrow;if(toThrow&&typeof toThrow=="object"&&toThrow.stack){toLog=[toThrow,toThrow.stack]}err(`exiting due to exception: ${toLog}`)}quit(status)});throw toThrow}}if(typeof print!="undefined"){globalThis.console??={};console.log=print;console.warn=console.error=globalThis.printErr??print}}else if(ENVIRONMENT_IS_WEB||ENVIRONMENT_IS_WORKER){if(ENVIRONMENT_IS_WORKER){scriptDirectory=self.location.href}else if(typeof document!="undefined"&&document.currentScript){scriptDirectory=document.currentScript.src}if(_scriptName){scriptDirectory=_scriptName}if(scriptDirectory.startsWith("blob:")){scriptDirectory=""}else{scriptDirectory=scriptDirectory.substr(0,scriptDirectory.replace(/[?#].*/,"").lastIndexOf("/")+1)}{if(ENVIRONMENT_IS_WORKER){readBinary=url=>{var xhr=new XMLHttpRequest;xhr.open("GET",url,false);xhr.responseType="arraybuffer";xhr.send(null);return new Uint8Array(xhr.response)}}readAsync=url=>fetch(url,{credentials:"same-origin"}).then(response=>{if(response.ok){return response.arrayBuffer()}return Promise.reject(new Error(response.status+" : "+response.url))})}}else{}var out=console.log.bind(console);var err=console.error.bind(console);Object.assign(Module,moduleOverrides);moduleOverrides=null;var wasmBinary;if(typeof atob=="undefined"){if(typeof global!="undefined"&&typeof globalThis=="undefined"){globalThis=global}globalThis.atob=function(input){var keyStr="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";var output="";var chr1,chr2,chr3;var enc1,enc2,enc3,enc4;var i=0;input=input.replace(/[^A-Za-z0-9\+\/\=]/g,"");do{enc1=keyStr.indexOf(input.charAt(i++));enc2=keyStr.indexOf(input.charAt(i++));enc3=keyStr.indexOf(input.charAt(i++));enc4=keyStr.indexOf(input.charAt(i++));chr1=enc1<<2|enc2>>4;chr2=(enc2&15)<<4|enc3>>2;chr3=(enc3&3)<<6|enc4;output=output+String.fromCharCode(chr1);if(enc3!==64){output=output+String.fromCharCode(chr2)}if(enc4!==64){output=output+String.fromCharCode(chr3)}}while(ifilename.startsWith(dataURIPrefix);function findWasmBinary(){var f="data:application/octet-stream;base64,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";return f}var wasmBinaryFile;function getBinarySync(file){if(file==wasmBinaryFile&&wasmBinary){return new Uint8Array(wasmBinary)}var binary=tryParseAsDataURI(file);if(binary){return binary}if(readBinary){return readBinary(file)}throw"both async and sync fetching of the wasm failed"}function getBinaryPromise(binaryFile){return Promise.resolve().then(()=>getBinarySync(binaryFile))}function instantiateArrayBuffer(binaryFile,imports,receiver){return getBinaryPromise(binaryFile).then(binary=>WebAssembly.instantiate(binary,imports)).then(receiver,reason=>{err(`failed to asynchronously prepare wasm: ${reason}`);abort(reason)})}function instantiateAsync(binary,binaryFile,imports,callback){return instantiateArrayBuffer(binaryFile,imports,callback)}function getWasmImports(){return{a:wasmImports}}function createWasm(){function receiveInstance(instance,module){wasmExports=instance.exports;wasmMemory=wasmExports["e"];updateMemoryViews();addOnInit(wasmExports["f"]);removeRunDependency("wasm-instantiate");return wasmExports}addRunDependency("wasm-instantiate");function receiveInstantiationResult(result){receiveInstance(result["instance"])}var info=getWasmImports();wasmBinaryFile??=findWasmBinary();instantiateAsync(wasmBinary,wasmBinaryFile,info,receiveInstantiationResult).catch(readyPromiseReject);return{}}class ExitStatus{name="ExitStatus";constructor(status){this.message=`Program terminated with exit(${status})`;this.status=status}}var callRuntimeCallbacks=callbacks=>{while(callbacks.length>0){callbacks.shift()(Module)}};var __abort_js=()=>abort("");var __emscripten_memcpy_js=(dest,src,num)=>HEAPU8.copyWithin(dest,src,src+num);var getHeapMax=()=>2147483648;var alignMemory=(size,alignment)=>Math.ceil(size/alignment)*alignment;var abortOnCannotGrowMemory=requestedSize=>{abort("OOM")};var growMemory=size=>{var b=wasmMemory.buffer;var pages=(size-b.byteLength+65535)/65536|0;try{wasmMemory.grow(pages);updateMemoryViews();return 1}catch(e){}};var _emscripten_resize_heap=requestedSize=>{var oldSize=HEAPU8.length;requestedSize>>>=0;var maxHeapSize=getHeapMax();if(requestedSize>maxHeapSize){abortOnCannotGrowMemory(requestedSize)}for(var cutDown=1;cutDown<=4;cutDown*=2){var overGrownHeapSize=oldSize*(1+.5/cutDown);overGrownHeapSize=Math.min(overGrownHeapSize,requestedSize+100663296);var newSize=Math.min(maxHeapSize,alignMemory(Math.max(requestedSize,overGrownHeapSize),65536));var replacement=growMemory(newSize);if(replacement){return true}}abortOnCannotGrowMemory(requestedSize)};var initRandomFill=()=>{if(typeof crypto=="object"&&typeof crypto["getRandomValues"]=="function"){return view=>crypto.getRandomValues(view)}else abort("initRandomDevice")};var randomFill=view=>(randomFill=initRandomFill())(view);var _random_get=(buffer,size)=>{randomFill(HEAPU8.subarray(buffer,buffer+size));return 0};var keepRuntimeAlive=()=>true;var _proc_exit=code=>{EXITSTATUS=code;if(!keepRuntimeAlive()){ABORT=true}quit_(code,new ExitStatus(code))};var exitJS=(status,implicit)=>{EXITSTATUS=status;_proc_exit(status)};var handleException=e=>{if(e instanceof ExitStatus||e=="unwind"){return EXITSTATUS}quit_(1,e)};var UTF8Decoder=typeof TextDecoder!="undefined"?new TextDecoder:undefined;var UTF8ArrayToString=(heapOrArray,idx=0,maxBytesToRead=NaN)=>{var endIdx=idx+maxBytesToRead;var endPtr=idx;while(heapOrArray[endPtr]&&!(endPtr>=endIdx))++endPtr;if(endPtr-idx>16&&heapOrArray.buffer&&UTF8Decoder){return UTF8Decoder.decode(heapOrArray.subarray(idx,endPtr))}var str="";while(idx>10,56320|ch&1023)}}return str};var UTF8ToString=(ptr,maxBytesToRead)=>ptr?UTF8ArrayToString(HEAPU8,ptr,maxBytesToRead):"";var wasmImports={d:__abort_js,c:__emscripten_memcpy_js,b:_emscripten_resize_heap,a:_random_get};var wasmExports=createWasm();var ___wasm_call_ctors=()=>(___wasm_call_ctors=wasmExports["f"])();var _setBuffers=Module["_setBuffers"]=(a0,a1)=>(_setBuffers=Module["_setBuffers"]=wasmExports["h"])(a0,a1);var _blockSamples=Module["_blockSamples"]=()=>(_blockSamples=Module["_blockSamples"]=wasmExports["i"])();var _intervalSamples=Module["_intervalSamples"]=()=>(_intervalSamples=Module["_intervalSamples"]=wasmExports["j"])();var _inputLatency=Module["_inputLatency"]=()=>(_inputLatency=Module["_inputLatency"]=wasmExports["k"])();var _outputLatency=Module["_outputLatency"]=()=>(_outputLatency=Module["_outputLatency"]=wasmExports["l"])();var _reset=Module["_reset"]=()=>(_reset=Module["_reset"]=wasmExports["m"])();var _presetDefault=Module["_presetDefault"]=(a0,a1)=>(_presetDefault=Module["_presetDefault"]=wasmExports["n"])(a0,a1);var _presetCheaper=Module["_presetCheaper"]=(a0,a1)=>(_presetCheaper=Module["_presetCheaper"]=wasmExports["o"])(a0,a1);var _configure=Module["_configure"]=(a0,a1,a2,a3)=>(_configure=Module["_configure"]=wasmExports["p"])(a0,a1,a2,a3);var _setTransposeFactor=Module["_setTransposeFactor"]=(a0,a1)=>(_setTransposeFactor=Module["_setTransposeFactor"]=wasmExports["q"])(a0,a1);var _setTransposeSemitones=Module["_setTransposeSemitones"]=(a0,a1)=>(_setTransposeSemitones=Module["_setTransposeSemitones"]=wasmExports["r"])(a0,a1);var _setFormantFactor=Module["_setFormantFactor"]=(a0,a1)=>(_setFormantFactor=Module["_setFormantFactor"]=wasmExports["s"])(a0,a1);var _setFormantSemitones=Module["_setFormantSemitones"]=(a0,a1)=>(_setFormantSemitones=Module["_setFormantSemitones"]=wasmExports["t"])(a0,a1);var _setFormantBase=Module["_setFormantBase"]=a0=>(_setFormantBase=Module["_setFormantBase"]=wasmExports["u"])(a0);var _seek=Module["_seek"]=(a0,a1)=>(_seek=Module["_seek"]=wasmExports["v"])(a0,a1);var _process=Module["_process"]=(a0,a1)=>(_process=Module["_process"]=wasmExports["w"])(a0,a1);var _flush=Module["_flush"]=a0=>(_flush=Module["_flush"]=wasmExports["x"])(a0);var _main=Module["_main"]=(a0,a1)=>(_main=Module["_main"]=wasmExports["y"])(a0,a1);Module["UTF8ToString"]=UTF8ToString;var calledRun;dependenciesFulfilled=function runCaller(){if(!calledRun)run();if(!calledRun)dependenciesFulfilled=runCaller};function callMain(){var entryFunction=_main;var argc=0;var argv=0;try{var ret=entryFunction(argc,argv);exitJS(ret,true);return ret}catch(e){return handleException(e)}}function run(){if(runDependencies>0){return}preRun();if(runDependencies>0){return}function doRun(){if(calledRun)return;calledRun=true;Module["calledRun"]=true;if(ABORT)return;initRuntime();preMain();readyPromiseResolve(Module);if(shouldRunNow)callMain();postRun()}{doRun()}}var shouldRunNow=true;run();moduleRtn=readyPromise;
+
+
+ return moduleRtn;
+}
+);
+})();
+
+globalThis.SignalsmithStretchCore = SignalsmithStretch;
diff --git a/static/vendor/soundtouch-processor.js b/static/vendor/soundtouch-processor.js
index 52eb564a..d5b4a510 100644
--- a/static/vendor/soundtouch-processor.js
+++ b/static/vendor/soundtouch-processor.js
@@ -173,6 +173,103 @@ class Biquad {
// actually land, and four biquads on one bus cost nothing worth counting.
const BUTTERWORTH_Q8 = [0.50979558, 0.60134489, 0.89997622, 2.56291545];
+// Attacks the tempo stage must not play twice (#728).
+//
+// Below 1x a sequence plays 70 ms of input but moves on by only 70 * tempo, so
+// consecutive sequences overlap and whatever sits in the overlap is heard
+// twice. Sustained sound hides that. A kick does not: at 0.75x it came out as a
+// flam about 50 ms long. When the next sequence would replay an attack, the
+// chain instead carries straight on from where the last sequence stopped, which
+// splices identical samples and so is seamless, and borrows the time that costs.
+// Later sequences stretch a little harder to pay it back.
+//
+// Nothing is split or filtered, so unlike the attack path this file once had,
+// the output is still built only from whole grains of the input.
+const ATTACK_FRAME_MS = 2; // energy frame the detector works in
+const ATTACK_HISTORY_MS = 20; // what an attack is measured against
+const ATTACK_RATIO = 4; // 6 dB above the recent level
+const ATTACK_FLOOR = 1e-6; // ignore noise rising out of near silence
+const ATTACK_GAP_MS = 30; // one attack per kick, not one per frame of it
+// An attack is marked this far ahead of the frame that crossed the threshold,
+// so the few milliseconds of rise before it count as part of the attack.
+const ATTACK_LEAD_MS = 4;
+// Borrowed input the chain may be ahead of its nominal clock by. The whole
+// mix, click included, goes through this one stage, so borrowing moves
+// everything together and the only effect is the playhead trailing the audio,
+// by this at most, until it is paid back.
+const MAX_BORROW_MS = 100;
+// Share of a sequence's advance used to pay the loan back, so repayment is
+// spread thinly rather than stretching one sequence hard.
+const REPAY_SHARE = 0.25;
+
+/**
+ * Marks attacks in a sample stream, by absolute sample position.
+ *
+ * Measured on the sample-to-sample difference rather than on the signal: the
+ * difference is dominated by high frequencies, which is what an attack is made
+ * of, while a bass line or a pad barely moves it. Plain energy missed most of
+ * the attacks in a full mix and placed the rest 8 to 30 ms late.
+ *
+ * Positions are absolute so they survive the FIFO compacting under them.
+ */
+class AttackTracker {
+ constructor(sr) {
+ this.frameLen = Math.max(1, Math.round(ATTACK_FRAME_MS * sr / 1000));
+ this.alpha = ATTACK_FRAME_MS / ATTACK_HISTORY_MS;
+ this.gap = Math.round(ATTACK_GAP_MS * sr / 1000);
+ this.lead = Math.round(ATTACK_LEAD_MS * sr / 1000);
+ this.clear();
+ }
+
+ clear() {
+ this.written = 0; // absolute position of the next sample pushed
+ this.frameAcc = 0;
+ this.frameFill = 0;
+ this.prevL = 0;
+ this.prevR = 0;
+ this.level = 0;
+ this.lastAttack = -Infinity;
+ this.attacks = [];
+ }
+
+ push(l, r, n) {
+ for (let i = 0; i < n; i++) {
+ const dl = l[i] - this.prevL, dr = r[i] - this.prevR;
+ this.prevL = l[i];
+ this.prevR = r[i];
+ this.frameAcc += dl * dl + dr * dr;
+ if (++this.frameFill < this.frameLen) continue;
+ const e = this.frameAcc / this.frameLen;
+ const start = this.written + i + 1 - this.frameLen - this.lead;
+ if (e > ATTACK_RATIO * this.level && e > ATTACK_FLOOR && start - this.lastAttack >= this.gap) {
+ this.attacks.push(start);
+ this.lastAttack = start;
+ }
+ this.level += this.alpha * (e - this.level);
+ this.frameAcc = 0;
+ this.frameFill = 0;
+ }
+ this.written += n;
+ }
+
+ /** True if an attack starts in [from, to), absolute positions. */
+ any(from, to) {
+ // Sorted, and below 1x the unread backlog, and so this list, keeps growing.
+ for (const a of this.attacks) {
+ if (a >= to) return false;
+ if (a >= from) return true;
+ }
+ return false;
+ }
+
+ /** Forget attacks the chain has consumed past. */
+ drop(before) {
+ let k = 0;
+ while (k < this.attacks.length && this.attacks[k] < before) k++;
+ if (k) this.attacks.splice(0, k);
+ }
+}
+
/**
* One WSOLA time-stretch chain: stereo in, stereo out, its own buffers.
*
@@ -183,7 +280,13 @@ const BUTTERWORTH_Q8 = [0.50979558, 0.60134489, 0.89997622, 2.56291545];
* folding, only attenuate whatever the fold produced.
*/
class Wsola {
- constructor(sr) {
+ /**
+ * `keepAttacks` must stay off for the pitch stages. Borrowing moves a chain's
+ * clock, and a pitch chain is aligned sample for sample with the unpitched
+ * drums beside it, so there it would pull the band away from the kit. It is
+ * safe on the shared tempo stage only because everything shares that clock.
+ */
+ constructor(sr, { keepAttacks = false } = {}) {
this.ovLen = Math.round(OVERLAP_MS * sr / 1000);
this.seekLen = Math.round(SEEK_MS * sr / 1000);
this.seqLen = Math.round(SEQUENCE_MS * sr / 1000);
@@ -209,6 +312,12 @@ class Wsola {
this._primed = false;
this.postFilter = null;
+
+ this._attacks = keepAttacks ? new AttackTracker(sr) : null;
+ this._maxBorrow = Math.round(MAX_BORROW_MS * sr / 1000);
+ this._head = 0; // absolute position of inL's read head
+ this._borrowed = 0; // input consumed ahead of the nominal clock
+ this._continue = false; // next sequence starts exactly where this one ended
}
clear() {
@@ -217,11 +326,23 @@ class Wsola {
this._carryL.fill(0); this._carryR.fill(0);
this._advanceRem = 0;
this._primed = false;
+ this._attacks?.clear();
+ this._head = 0;
+ this._borrowed = 0;
+ this._continue = false;
}
push(l, r, n) {
this.inL.push(l, 0, n);
this.inR.push(r, 0, n);
+ this._attacks?.push(l, r, n);
+ }
+
+ _consume(n) {
+ this.inL.consume(n);
+ this.inR.consume(n);
+ this._head += n;
+ this._attacks?.drop(this._head);
}
/** Run sequences until `want` output samples are queued, or input runs out. */
@@ -236,7 +357,10 @@ class Wsola {
_sequence(tempo) {
const ovLen = this.ovLen, midLen = this.midLen, seqLen = this.seqLen;
const outLen = ovLen + midLen;
- const bestOff = findBestOffset(this._carryL, ovLen, this.inL, this.seekLen);
+ // After carrying straight on, the carry is the very samples at the head,
+ // so offset 0 splices them onto themselves. A search could land elsewhere.
+ const bestOff = this._continue ? 0 : findBestOffset(this._carryL, ovLen, this.inL, this.seekLen);
+ this._continue = false;
for (let i = 0; i < ovLen; i++) {
const w = i / ovLen;
@@ -257,14 +381,125 @@ class Wsola {
this.outL.push(this._tmpL, 0, outLen);
this.outR.push(this._tmpR, 0, outLen);
- const exact = (seqLen - ovLen) * tempo + this._advanceRem;
+ const nominal = (seqLen - ovLen) * tempo;
+ const repay = this._attacks ? Math.min(this._borrowed, nominal * REPAY_SHARE) : 0;
+ const exact = nominal - repay + this._advanceRem;
const whole = Math.floor(exact);
+
+ // Input this sequence played in full ends at `played`; the carry after it
+ // is faded out under the next sequence's head. The next sequence starts no
+ // earlier than `whole`, so an attack in between would be heard twice.
+ if (this._attacks && tempo < 1) {
+ const played = bestOff + outLen;
+ const cost = played - nominal;
+ if (this._borrowed + cost <= this._maxBorrow
+ && this._attacks.any(this._head + whole, this._head + played + ovLen)) {
+ this._borrowed += cost;
+ this._continue = true;
+ this._consume(played);
+ return;
+ }
+ }
+
+ this._borrowed -= repay;
this._advanceRem = exact - whole;
// The similarity search is local to this sequence. Folding bestOff into
// the nominal advance makes content-dependent offsets accumulate into a
// clock error, which is especially audible against unpitched drums.
- this.inL.consume(whole);
- this.inR.consume(whole);
+ this._consume(whole);
+ }
+}
+
+// The shared tempo stage, when the Signalsmith core loaded (#729).
+//
+// WSOLA slows audio down by repeating overlapping fragments of it, which is
+// heard as an echo on anything sustained. Signalsmith Stretch works in the
+// frequency domain and repeats nothing. 40 ms blocks were chosen by ear against
+// 30, 60 and the library's 120 ms default: 120 softened a quarter of the drum
+// attacks in a full mix, 30 blurred the low end.
+const SIGNALSMITH_BLOCK_MS = 40;
+const SIGNALSMITH_INTERVAL_MS = 10;
+// Largest input one render quantum can ask for is 128 * the tempo maximum.
+const SIGNALSMITH_MAX_BLOCK = 128 * 4;
+
+/**
+ * The same shape as a Wsola chain, as far as the processor uses one: push,
+ * fill, clear and an output FIFO pair. Anything else would mean a second code
+ * path through process().
+ *
+ * The core stretches by whatever ratio it is handed, so each quantum feeds it
+ * 128 * tempo input samples for 128 output samples. The fraction carries over,
+ * so the rate is exact on average and nothing drifts against the click.
+ */
+class SignalsmithTempo {
+ constructor(core, sr) {
+ this._core = core;
+ core._main();
+ core._configure(
+ 2,
+ Math.round(SIGNALSMITH_BLOCK_MS * sr / 1000),
+ Math.round(SIGNALSMITH_INTERVAL_MS * sr / 1000),
+ false,
+ );
+ core._reset();
+ this.inputLatency = core._inputLatency();
+ this.outputLatency = core._outputLatency();
+ this._len = SIGNALSMITH_MAX_BLOCK;
+ this._ptr = core._setBuffers(2, this._len);
+ this._heap = null;
+ this.inL = new FloatFifo();
+ this.inR = new FloatFifo();
+ this.outL = new FloatFifo();
+ this.outR = new FloatFifo();
+ this._carry = 0;
+ }
+
+ // Views onto the core's buffers, rebuilt only if its memory was replaced.
+ _views() {
+ const buffer = this._core.HEAP8.buffer;
+ if (!this._heap || this._heap.buffer !== buffer) {
+ this._heap = new Float32Array(buffer, this._ptr, this._len * 4);
+ }
+ return this._heap;
+ }
+
+ clear() {
+ this.inL.clear(); this.inR.clear();
+ this.outL.clear(); this.outR.clear();
+ this._core._reset();
+ this._carry = 0;
+ }
+
+ push(l, r, n) {
+ this.inL.push(l, 0, n);
+ this.inR.push(r, 0, n);
+ }
+
+ fill(tempo, want) {
+ const block = 128;
+ while (this.outL.avail < want) {
+ const exact = block * tempo + this._carry;
+ const take = Math.min(Math.floor(exact), this._len);
+ if (this.inL.avail < take) return;
+ this._carry = exact - take;
+ const heap = this._views();
+ const len = this._len;
+ for (let i = 0; i < take; i++) {
+ heap[i] = this.inL.peek(i);
+ heap[len + i] = this.inR.peek(i);
+ }
+ this.inL.consume(take);
+ this.inR.consume(take);
+ this._core._process(take, block);
+ const out = this._views();
+ this.outL.push(out, 2 * len, block);
+ this.outR.push(out, 3 * len, block);
+ }
+ }
+
+ /** Output samples between a sample entering and leaving, at this tempo. */
+ latencyFrames(tempo) {
+ return this.inputLatency / tempo + this.outputLatency;
}
}
@@ -459,10 +694,15 @@ class SoundTouchProcessor extends AudioWorkletProcessor {
constructor() {
super();
- this._tempo = new Wsola(sampleRate);
+ // WSOLA stays as the tempo stage until the Signalsmith core is ready, and
+ // for good if it never is: a browser without WebAssembly in worklets, or a
+ // CSP that blocks it. Its sizes also set the priming below either way.
+ this._wsola = new Wsola(sampleRate, { keepAttacks: true });
+ this._tempo = this._wsola;
+ this._signalsmith = null;
// Silence every bus is primed with, before its own alignment pad, so they
// share one clock and each chain can produce from its first block.
- this._commonPrime = this._tempo.needed + PRIME_CUSHION;
+ this._commonPrime = this._wsola.needed + PRIME_CUSHION;
this._chains = new Array(INPUT_COUNT).fill(null);
this._idle = new Array(INPUT_COUNT).fill(0);
this._unpitchedL = new FloatFifo();
@@ -487,13 +727,39 @@ class SoundTouchProcessor extends AudioWorkletProcessor {
this.port.postMessage({
type: 'latency',
frames: this._commonPrime
- + alignmentPad(this._tempo.ovLen + this._tempo.midLen, 1),
+ + alignmentPad(this._wsola.ovLen + this._wsola.midLen, 1),
+ });
+ }
+ this._reportTempoStage();
+
+ // Loaded as its own worklet module ahead of this one; see
+ // signalsmith-stretch.js. Instantiating is asynchronous, so the stage is
+ // only swapped in at the next flush, never under audio already playing.
+ const core = globalThis.SignalsmithStretchCore;
+ if (typeof core === 'function') {
+ core().then((module) => {
+ this._signalsmith = new SignalsmithTempo(module, sampleRate);
+ }).catch((err) => {
+ this.port?.postMessage({ type: 'tempoStageFailed', message: String(err?.message || err) });
});
}
}
+ // The tempo stage's own latency, which the engine adds when tempo is not 1.
+ // Signalsmith's depends on the tempo, so it is sent as its two parts.
+ _reportTempoStage() {
+ if (!this.port) return;
+ const ss = this._tempo === this._signalsmith ? this._signalsmith : null;
+ this.port.postMessage({
+ type: 'tempoStage',
+ stage: ss ? 'signalsmith' : 'wsola',
+ inputFrames: ss ? ss.inputLatency : 0,
+ outputFrames: ss ? ss.outputLatency : 0,
+ });
+ }
+
_primeUnpitched() {
- const outLen = this._tempo.ovLen + this._tempo.midLen;
+ const outLen = this._wsola.ovLen + this._wsola.midLen;
const pad = new Float32Array(this._commonPrime + alignmentPad(outLen, 1));
this._unpitchedL.clear();
this._unpitchedR.clear();
@@ -502,6 +768,10 @@ class SoundTouchProcessor extends AudioWorkletProcessor {
}
_flush() {
+ if (this._signalsmith && this._tempo !== this._signalsmith) {
+ this._tempo = this._signalsmith;
+ this._reportTempoStage();
+ }
this._tempo.clear();
this._mixFifoL.clear();
this._mixFifoR.clear();
diff --git a/tests/acceptance/README.md b/tests/acceptance/README.md
index 65a226de..4571f3fb 100644
--- a/tests/acceptance/README.md
+++ b/tests/acceptance/README.md
@@ -113,7 +113,7 @@ window are added, so the karaoke checks do not depend on the window being on
top. The window is resized with the Win32 API, because the now-playing card
only shows in a window wider than 1460 px.
-E4 blocks `lrclib.net` for the page alone. E6 starts the app a second time
+E4 answers the page's lyrics lookup with the server's "LRCLIB unreachable" (502), for the page alone. E6 starts the app a second time
with every outside request sent to a proxy that nobody listens on
(`HTTP(S)_PROXY` for the backend, `--proxy-server` for WebView2), loopback
excepted: offline for this app, while the machine keeps its network.
diff --git a/tests/acceptance/acceptance.spec.mjs b/tests/acceptance/acceptance.spec.mjs
index 628ed8f2..3cd85f3e 100644
--- a/tests/acceptance/acceptance.spec.mjs
+++ b/tests/acceptance/acceptance.spec.mjs
@@ -103,10 +103,9 @@ test.afterEach(async ({ app }, testInfo) => {
if (testInfo.status === testInfo.expectedStatus) return;
await shot(app.page, testInfo, "failure").catch(() => {});
const message = testInfo.error?.message || "";
- const evidence = serviceEvidence(app.page, checkStartedAt, {
- // Blocked on purpose by E4.
- ignoreHosts: testInfo.title.startsWith("E4") ? ["lrclib.net"] : [],
- });
+ // E4's refused lookup is a request to the app's own server, which this does
+ // not count as an outside service.
+ const evidence = serviceEvidence(app.page, checkStartedAt);
// An outage only explains a failure it could have caused: an import that
// YouTube refused, or a request from the page itself that failed. A service
// in the backend log alone is noted, not blamed.
@@ -342,7 +341,7 @@ test(title("A3"), async ({ app }, testInfo) => {
// ─── Now playing and song details ───────────────────────────────────────────
// Steps: import any song and open it. Expect, left to right: the link field,
-// the Extract options, Split stems, then the Now playing card with the
+// the Extract options, Extract stems, then the Now playing card with the
// artwork, the heart on its left and the (i) on its right.
test(title("N1"), async ({ app }, testInfo) => {
const { page } = app;
@@ -367,8 +366,8 @@ test(title("N1"), async ({ app }, testInfo) => {
// chips under the field; everything else follows them to the right.
const besideOrUnder = url.right <= extract.left || (Math.abs(extract.left - url.left) < 40 && extract.top >= url.bottom - 2);
expect(besideOrUnder, "the Extract options follow the link field").toBe(true);
- expect(Math.max(url.right, extract.right) <= split.left, "Split stems follows them").toBe(true);
- expect(split.right <= card.left, "the card comes after Split stems").toBe(true);
+ expect(Math.max(url.right, extract.right) <= split.left, "Extract stems follows them").toBe(true);
+ expect(split.right <= card.left, "the card comes after Extract stems").toBe(true);
// One row: every one of them overlaps the card's height.
for (const b of [url, extract, split]) expect(b.top < card.bottom && b.bottom > card.top, "one row").toBe(true);
await expect(page.locator("#nowPlayingPanel .np-legend")).toHaveText("Now playing");
@@ -1021,16 +1020,19 @@ test(title("V2"), async ({ app }, testInfo) => {
// Expect: "Could not reach LRCLIB. Check your connection and try again." in
// the Lyrics panel; nothing floats over the top bar.
//
-// LRCLIB is blocked for the page alone (page.route over CDP): the rest of the
-// machine keeps its network. The page only asks LRCLIB itself for a track the
-// server kept no lyrics for, which the tagged tone file is.
+// The page asks the server to look lyrics up (#719), and the server answers
+// 502 when LRCLIB cannot be reached. That answer is given for the page alone
+// (page.route over CDP), so the rest of the machine keeps its network. The
+// lookup is only asked for a track the server kept no lyrics for, which the
+// tagged tone file is.
test(title("E4"), async ({ app }, testInfo) => {
const { page } = app;
await wideWindow(page);
const id = await trackFor(page, "localMp3");
const kept = await fetch(`${readState().baseURL}/api/jobs/${id}/lyrics`);
- test.skip(kept.status !== 404, `The server kept lyrics for the tone file (HTTP ${kept.status}), so the page would not ask LRCLIB.`);
- await page.route(/^https:\/\/lrclib\.net\//, (route) => route.abort("internetdisconnected"));
+ test.skip(kept.status !== 404, `The server kept lyrics for the tone file (HTTP ${kept.status}), so the page would not ask for a lookup.`);
+ const LOOKUP = /\/api\/jobs\/[^/]+\/lyrics\/lookup$/;
+ await page.route(LOOKUP, (route) => route.fulfill({ status: 502, json: { detail: "lyrics service unreachable" } }));
try {
await openTrack(page, id);
await openLyrics(page);
@@ -1050,7 +1052,7 @@ test(title("E4"), async ({ app }, testInfo) => {
expect(floating).toBe(0);
await shot(page, testInfo, "offline");
} finally {
- await page.unroute(/^https:\/\/lrclib\.net\//);
+ await page.unroute(LOOKUP);
}
});
diff --git a/tests/acceptance/helpers.mjs b/tests/acceptance/helpers.mjs
index bda75cf7..c52bfdee 100644
--- a/tests/acceptance/helpers.mjs
+++ b/tests/acceptance/helpers.mjs
@@ -233,7 +233,7 @@ export async function showLibrary(page) {
await expect(lib).toHaveAttribute("aria-pressed", "true");
}
-/** Paste a link in the top bar's field and press Split stems. Returns the job id. */
+/** Paste a link in the top bar's field and press Extract stems. Returns the job id. */
export async function importLink(page, url) {
const field = page.locator("#url");
await field.fill(url);
@@ -242,7 +242,7 @@ export async function importLink(page, url) {
page.locator("#submit").click(),
]);
const body = await res.json().catch(() => ({}));
- if (!res.ok()) throw new Error(`Split stems refused ${url}: ${res.status()} ${body.detail || ""}`);
+ if (!res.ok()) throw new Error(`Extract stems refused ${url}: ${res.status()} ${body.detail || ""}`);
return body.job_id;
}
@@ -255,7 +255,7 @@ export async function importFile(page, file) {
page.locator("#submit").click(),
]);
const body = await res.json().catch(() => ({}));
- if (!res.ok()) throw new Error(`Split stems refused ${path.basename(file)}: ${res.status()} ${body.detail || ""}`);
+ if (!res.ok()) throw new Error(`Extract stems refused ${path.basename(file)}: ${res.status()} ${body.detail || ""}`);
return body.job_id;
}
@@ -327,7 +327,7 @@ export async function queueImports(page) {
/**
* The job id of an import, waiting for it to finish. A link YouTube refused
* (a 403 on the media now and then) is split once more, as a person would
- * press Split stems again; the retry is recorded in the state file so the
+ * press Extract stems again; the retry is recorded in the state file so the
* check can say so.
*/
export async function songJob(page, key) {
diff --git a/tests/e2e/about-reach.spec.mjs b/tests/e2e/about-reach.spec.mjs
new file mode 100644
index 00000000..c762974c
--- /dev/null
+++ b/tests/e2e/about-reach.spec.mjs
@@ -0,0 +1,36 @@
+// About this song can be opened at any window width (#735).
+//
+// Its button lived only on the Now Playing card, and daw.css hid that whole
+// card below 1460 px, so a maximised laptop window had no way to open it. The
+// card now gives way in steps instead: the artwork and the meta line go first,
+// then the title, and the heart and the About button stay.
+
+import { test, expect } from "@playwright/test";
+import { openStudio } from "./helpers.mjs";
+
+for (const width of [1024, 1280, 1366, 1600]) {
+ test(`About this song opens from the card at ${width} px`, async ({ page }) => {
+ await page.setViewportSize({ width, height: 800 });
+ await openStudio(page);
+ const button = page.locator("#np-details-btn");
+ await expect(button).toBeVisible();
+ await expect(page.locator("#fav-btn")).toBeVisible();
+ // On screen and inside the bar, not pushed past its edge.
+ const box = await button.boundingBox();
+ const bar = await page.locator(".daw-composer").boundingBox();
+ expect(box.width).toBeGreaterThan(20);
+ expect(box.x + box.width).toBeLessThanOrEqual(bar.x + bar.width + 0.5);
+ await button.click();
+ await expect(page.locator("#artistDialog")).toBeVisible();
+ });
+}
+
+test("Extract stems sits under Detect structure and the composer keeps one line of chips", async ({ page }) => {
+ await page.setViewportSize({ width: 1600, height: 800 });
+ await openStudio(page);
+ const detect = await page.locator("#autoSectionsBtn").boundingBox();
+ const extract = await page.locator("#submit").boundingBox();
+ await expect(page.locator("#submit")).toHaveText(/Extract stems/);
+ expect(Math.abs(detect.x - extract.x)).toBeLessThan(1);
+ expect(extract.y).toBeGreaterThan(detect.y + detect.height - 1);
+});
diff --git a/tests/e2e/audio-tags-backfill.spec.mjs b/tests/e2e/audio-tags-backfill.spec.mjs
index 2a9c1d69..74f8b7c2 100644
--- a/tests/e2e/audio-tags-backfill.spec.mjs
+++ b/tests/e2e/audio-tags-backfill.spec.mjs
@@ -16,13 +16,13 @@ import {
stubAudioTags,
stubExportEndpoints,
stubUpdateCheck,
+ LYRICS_LOOKUP,
} from "./helpers.mjs";
// Wide enough for the now-playing card, which the bar hides below 1460px.
test.use({ viewport: { width: 1600, height: 900 } });
const WIKIMEDIA = /^https:\/\/([a-z]+\.wikipedia\.org|www\.wikidata\.org|query\.wikidata\.org)\//;
-const LRCLIB = /^https:\/\/lrclib\.net\//;
// Longer than artistInfo.js's wait after a track opens.
const PAST_THE_WAIT_MS = 2000;
@@ -266,15 +266,12 @@ test.describe("tags for tracks imported before they were read", () => {
test("the Lyrics tab, open while the tags arrive, looks them up", async ({ page }) => {
await stubWikimedia(page);
+ // The tab asks the server to look them up (#719), which has the tags the
+ // read just stored; it is answered here with nothing found.
const lrclib = [];
- await page.route(LRCLIB, (route) => {
+ await page.route(LYRICS_LOOKUP, (route) => {
lrclib.push(route.request().url());
- return route.fulfill({
- status: 200,
- contentType: "application/json",
- headers: { "access-control-allow-origin": "*" },
- body: "[]",
- });
+ return route.fulfill({ status: 404, json: { detail: "no lyrics", others: [] } });
});
let release;
const hold = new Promise((resolve) => { release = resolve; });
@@ -287,6 +284,6 @@ test.describe("tags for tracks imported before they were read", () => {
release();
await expect.poll(() => lrclib.length, { timeout: 15000 }).toBeGreaterThan(0);
- expect(decodeURIComponent(lrclib[0]).replace(/\+/g, " ")).toContain("Dream Theater");
+ await expect(page.locator("#lyricsStatus")).toContainText("No lyrics found");
});
});
diff --git a/tests/e2e/composer-arming.spec.mjs b/tests/e2e/composer-arming.spec.mjs
index a57bbfe5..88b90001 100644
--- a/tests/e2e/composer-arming.spec.mjs
+++ b/tests/e2e/composer-arming.spec.mjs
@@ -1,4 +1,4 @@
-// What the Split stems button is allowed to be pointed at (#635).
+// What the Extract stems button is allowed to be pointed at (#635).
//
// The composer is an input the button submits, not a caption for whatever
// track is open. Opening a track writes its source back into it, and for an
diff --git a/tests/e2e/favorite-reach.spec.mjs b/tests/e2e/favorite-reach.spec.mjs
new file mode 100644
index 00000000..4c1c02d6
--- /dev/null
+++ b/tests/e2e/favorite-reach.spec.mjs
@@ -0,0 +1,74 @@
+// A track can be favourited at any window width (#724).
+//
+// The only heart used to be the Now Playing card's, and daw.css hid that whole
+// card below 1460 px. A maximised laptop window is under that, so there was no
+// way to favourite at all. Library and Favorites rows have one now, and every
+// heart goes through one toggle, so they cannot disagree. The card stays in a
+// compact form at narrow widths too since #735, so both hearts are on screen.
+
+import { test, expect } from "@playwright/test";
+import { JOB_ID, SIBLING_JOB_ID, openStudio, readCatalogState } from "./helpers.mjs";
+
+const row = (page, id) => page.locator(`#catalogList .cat-item[data-id="${id}"]`).first();
+const rowHeart = (page, id) => row(page, id).locator(".cat-fav");
+const favoriteIn = async (page, id) => Boolean((await readCatalogState(page))?.tracks?.[id]?.favorite);
+
+test.describe("favourites at a narrow window", () => {
+ test.use({ viewport: { width: 1280, height: 800 } });
+
+ test("a library row can favourite a track that is not the one playing", async ({ page }) => {
+ await openStudio(page);
+
+ await row(page, SIBLING_JOB_ID).hover();
+ await expect(rowHeart(page, SIBLING_JOB_ID)).toBeVisible();
+ await rowHeart(page, SIBLING_JOB_ID).click();
+
+ expect(await favoriteIn(page, SIBLING_JOB_ID)).toBe(true);
+ await expect(rowHeart(page, SIBLING_JOB_ID)).toHaveAttribute("aria-pressed", "true");
+ await expect(row(page, SIBLING_JOB_ID)).toHaveClass(/\bis-fav\b/);
+ // The heart is a button on the row, not a way of opening the track.
+ await expect(row(page, JOB_ID)).toHaveClass(/\bactive\b/);
+ await expect(row(page, SIBLING_JOB_ID)).not.toHaveClass(/\bactive\b/);
+ });
+
+ test("the Favorites view can take a track back out", async ({ page }) => {
+ await openStudio(page);
+ await row(page, SIBLING_JOB_ID).hover();
+ await rowHeart(page, SIBLING_JOB_ID).click();
+
+ await page.locator(".rail-favorites").click();
+ await expect(row(page, SIBLING_JOB_ID)).toBeVisible();
+ await row(page, SIBLING_JOB_ID).hover();
+ await rowHeart(page, SIBLING_JOB_ID).click();
+
+ await expect(row(page, SIBLING_JOB_ID)).toHaveCount(0);
+ expect(await favoriteIn(page, SIBLING_JOB_ID)).toBe(false);
+ });
+
+ test("keyboard focus reveals the row heart", async ({ page }) => {
+ await openStudio(page);
+ await rowHeart(page, SIBLING_JOB_ID).focus();
+ // Polled: the reveal fades in over a short transition.
+ await expect.poll(() => row(page, SIBLING_JOB_ID).locator(".cat-actions")
+ .evaluate((el) => Number(getComputedStyle(el).opacity))).toBeGreaterThan(0.9);
+ });
+});
+
+test.describe("favourites at a wide window", () => {
+ test.use({ viewport: { width: 1600, height: 900 } });
+
+ test("the row heart and the Now Playing heart stay in step", async ({ page }) => {
+ await openStudio(page);
+ const npHeart = page.locator("#fav-btn");
+ await expect(npHeart).toBeVisible();
+ await expect(npHeart).toHaveAttribute("aria-pressed", "false");
+
+ await row(page, JOB_ID).hover();
+ await rowHeart(page, JOB_ID).click();
+ await expect(npHeart).toHaveAttribute("aria-pressed", "true");
+
+ await npHeart.click();
+ await expect(rowHeart(page, JOB_ID)).toHaveAttribute("aria-pressed", "false");
+ expect(await favoriteIn(page, JOB_ID)).toBe(false);
+ });
+});
diff --git a/tests/e2e/favorite-sync.spec.mjs b/tests/e2e/favorite-sync.spec.mjs
new file mode 100644
index 00000000..0b340592
--- /dev/null
+++ b/tests/e2e/favorite-sync.spec.mjs
@@ -0,0 +1,57 @@
+// Favourites are kept on the server, so the phone and the studio agree (#734).
+//
+// They lived only in the studio's own store, so the phone had no heart to
+// press and its Favorites chip listed every track. The server is stubbed here
+// (stubFavorites) so no spec leaves a favourite behind on the shared backend;
+// the endpoint itself is covered by tests/test_jobs_favorite.py.
+
+import { test, expect } from "@playwright/test";
+import { JOB_ID, SIBLING_JOB_ID, openStudio, readCatalogState, stubFavorites } from "./helpers.mjs";
+
+const row = (page, id) => page.locator(`#catalogList .cat-item[data-id="${id}"]`).first();
+
+test.describe("studio", () => {
+ test.use({ viewport: { width: 1600, height: 900 } });
+
+ test("a heart pressed in the studio is saved on the server", async ({ page }) => {
+ const { favoriteWrites } = await openStudio(page);
+ await row(page, SIBLING_JOB_ID).hover();
+ await row(page, SIBLING_JOB_ID).locator(".cat-fav").click();
+ await expect.poll(() => favoriteWrites).toContainEqual({ id: SIBLING_JOB_ID, favorite: true });
+ });
+
+ test("a favourite set on the phone shows in the studio", async ({ page }) => {
+ await openStudio(page, { serverFavorites: { [SIBLING_JOB_ID]: true } });
+ await expect(row(page, SIBLING_JOB_ID)).toHaveClass(/\bis-fav\b/);
+ expect((await readCatalogState(page))?.tracks?.[SIBLING_JOB_ID]?.favorite).toBe(true);
+ });
+});
+
+test.describe("phone", () => {
+ test.use({ viewport: { width: 390, height: 844 } });
+
+ const openPhone = async (page, serverFavorites) => {
+ const writes = await stubFavorites(page, serverFavorites);
+ await page.goto("/?ui=mobile", { waitUntil: "domcontentloaded" });
+ await page.locator('[data-action="tab"][data-tab="library"]').first().click();
+ await page.locator(`.track[data-id="${JOB_ID}"]`).first().waitFor({ timeout: 20000 });
+ return writes;
+ };
+
+ test("the Favorites chip lists only favourites", async ({ page }) => {
+ await openPhone(page, { [JOB_ID]: true });
+ await page.locator('[data-action="filter"][data-filter="Favorites"]').click();
+ await expect(page.locator(`.track[data-id="${JOB_ID}"]`)).toBeVisible();
+ await expect(page.locator(`.track[data-id="${SIBLING_JOB_ID}"]`)).toHaveCount(0);
+ });
+
+ test("a heart on the phone is saved and does not open the track", async ({ page }) => {
+ const writes = await openPhone(page, {});
+ const heart = page.locator(`.track-fav[data-id="${SIBLING_JOB_ID}"]`);
+ await heart.click();
+ await expect(heart).toHaveAttribute("aria-pressed", "true");
+ await expect.poll(() => writes).toContainEqual({ id: SIBLING_JOB_ID, favorite: true });
+ // Still on the library, not taken to the player.
+ await expect(page.locator(`.track[data-id="${SIBLING_JOB_ID}"]`)).toBeVisible();
+ });
+});
diff --git a/tests/e2e/helpers.mjs b/tests/e2e/helpers.mjs
index 13e19b14..56eb46f3 100644
--- a/tests/e2e/helpers.mjs
+++ b/tests/e2e/helpers.mjs
@@ -253,8 +253,37 @@ export async function stubUpdateCheck(page, { available = false } = {}) {
}
/** Open the fixture track in the studio and wait until the transport is live. */
-export async function openStudio(page, { tauri = false, updateAvailable = false } = {}) {
+/**
+ * Keep favourites off the shared e2e backend (#734).
+ *
+ * A heart now writes to the server, and every spec shares one server, so a
+ * favourite set by one test would come back through GET /api/jobs into the
+ * next one's library. Writes are answered here instead, and the server's
+ * value stays null, which the desktop reads as "never said". A test about the
+ * sync itself passes `serverFavorites` to stand in for what the server knows.
+ */
+export async function stubFavorites(page, serverFavorites = {}) {
+ const writes = [];
+ await page.route("**/api/jobs/*/favorite", async (route) => {
+ const id = new URL(route.request().url()).pathname.split("/")[3];
+ const { favorite } = JSON.parse(route.request().postData() || "{}");
+ writes.push({ id, favorite });
+ serverFavorites[id] = favorite;
+ await route.fulfill({ json: { job_id: id, favorite } });
+ });
+ await page.route(/\/api\/jobs(\?.*)?$/, async (route) => {
+ if (route.request().method() !== "GET") return route.continue();
+ const res = await route.fetch();
+ const jobs = await res.json();
+ for (const j of jobs) j.favorite = serverFavorites[j.job_id] ?? null;
+ await route.fulfill({ response: res, json: jobs });
+ });
+ return writes;
+}
+
+export async function openStudio(page, { tauri = false, updateAvailable = false, serverFavorites = {} } = {}) {
await seedLibrary(page);
+ const favoriteWrites = await stubFavorites(page, serverFavorites);
if (tauri) await stubTauri(page);
await stubExportEndpoints(page);
await stubUpdateCheck(page, { available: updateAvailable });
@@ -268,6 +297,7 @@ export async function openStudio(page, { tauri = false, updateAvailable = false
null,
{ timeout: 20000 },
);
+ return { favoriteWrites };
}
/**
@@ -322,3 +352,60 @@ export const exportUi = (page) => ({
await page.locator("#t-export-panel:not(.hidden)").waitFor({ timeout: 5000 });
},
});
+
+/** The server's lyrics lookup, which the Lyrics tab asks rather than LRCLIB (#719). */
+export const LYRICS_LOOKUP = /\/api\/jobs\/[a-f0-9]{12}\/lyrics\/lookup$/;
+
+/**
+ * Stand in for the server's lyrics lookup, so the lyrics specs run offline and
+ * never reach LRCLIB through the shared backend.
+ *
+ * `rows` are LRCLIB rows. Like the server, it keeps only versions of `song` by
+ * `artist` (brackets and a " - ..." tail aside), keeps the first within 3 s of
+ * the track's `duration` and offers the others with it, or offers them all
+ * when none is that length. What it kept or offered is then what GET
+ * .../lyrics answers, as the server's lyrics.json would. The rule itself is
+ * tested against the real server in tests/test_lyrics_lookup.py; this only
+ * has to answer the way it does. Resolves to the requests the page made:
+ * [{ id, body }].
+ */
+export async function stubLyricsLookup(page, { rows = [], artist = "", song = "", duration = 6, offline = false, nothingKnown = false } = {}) {
+ const asked = [];
+ const kept = {};
+ const offered = {};
+ const jobOf = (route) => new URL(route.request().url()).pathname.split("/")[3];
+ const version = (r) => ({
+ source: "lrclib",
+ lrclib_id: r.id,
+ track: r.trackName,
+ artist: r.artistName,
+ album: r.albumName || "",
+ duration: r.duration,
+ instrumental: Boolean(r.instrumental),
+ synced: r.syncedLyrics || "",
+ plain: r.plainLyrics || "",
+ });
+ const songKey = (s) => String(s || "").replace(/[([{][^)\]}]*[)\]}]/g, "").replace(/\s+-\s+.*$/, "").trim().toLowerCase();
+ await page.route(/\/api\/jobs\/[a-f0-9]{12}\/lyrics$/, (route) => {
+ if (route.request().method() !== "GET") return route.fallback();
+ const id = jobOf(route);
+ if (kept[id]) return route.fulfill({ json: kept[id], headers: { "cache-control": "no-cache" } });
+ if (offered[id]?.length) return route.fulfill({ status: 404, json: { detail: "no lyrics", others: offered[id] } });
+ return route.fallback();
+ });
+ await page.route(LYRICS_LOOKUP, (route) => {
+ const id = jobOf(route);
+ asked.push({ id, body: JSON.parse(route.request().postData() || "{}") });
+ if (offline) return route.fulfill({ status: 502, json: { detail: "lyrics service unreachable" } });
+ if (nothingKnown) return route.fulfill({ status: 404, json: { detail: "nothing to look up", others: [], nothing_known: true } });
+ const mine = rows.filter((r) => r.artistName === artist && songKey(r.trackName) === songKey(song)).map(version);
+ const best = mine.find((v) => Math.abs(v.duration - duration) <= 3);
+ if (best) {
+ kept[id] = { v: 1, ...best, timing: "exact", others: mine.filter((v) => v !== best) };
+ return route.fulfill({ json: kept[id] });
+ }
+ offered[id] = mine;
+ return route.fulfill({ status: 404, json: { detail: "no lyrics", others: mine } });
+ });
+ return asked;
+}
diff --git a/tests/e2e/key-card.spec.mjs b/tests/e2e/key-card.spec.mjs
new file mode 100644
index 00000000..56c6e7be
--- /dev/null
+++ b/tests/e2e/key-card.spec.mjs
@@ -0,0 +1,64 @@
+// The key is one label on one card, and it fits (#736).
+//
+// It used to be "D maj" on the Key card, "Major" under it and "Major" again on
+// a Scale card of its own, while the Key card was too narrow for anything
+// longer. The longest label analysis can produce is a sharp harmonic minor, and
+// German spells it longest, so that is what this measures.
+
+import { test, expect } from "@playwright/test";
+import {
+ JOB_ID, SIBLING_JOB_ID, TRACK_TITLE, SIBLING_TITLE,
+ fixtureTrack, seedCatalogState, stubExportEndpoints, stubUpdateCheck,
+} from "./helpers.mjs";
+
+async function openWithKey(page, { language }) {
+ await page.addInitScript((code) => window.localStorage.setItem("stemdeck.language", JSON.stringify(code)), language);
+ await seedCatalogState(page, {
+ folders: [
+ { id: "f-unsorted", name: "Unsorted", items: [JOB_ID, SIBLING_JOB_ID], color: null },
+ { id: "trash", name: "Trash", items: [], color: null },
+ ],
+ tracks: {
+ [JOB_ID]: { ...fixtureTrack(JOB_ID, TRACK_TITLE), key: "F# min", scale: "Harmonic Minor", keyConfidence: 72 },
+ [SIBLING_JOB_ID]: fixtureTrack(SIBLING_JOB_ID, SIBLING_TITLE),
+ },
+ });
+ // The server's own record wins over the store once the page syncs, and the
+ // fixture job says "C maj", so the answer is rewritten on the way in.
+ await page.route(`**/api/jobs**`, async (route) => {
+ const response = await route.fetch();
+ let body = await response.text();
+ if ((response.headers()["content-type"] || "").includes("json")) {
+ body = body.replaceAll('"key":"C maj"', '"key":"F# min"')
+ .replaceAll('"key": "C maj"', '"key": "F# min"')
+ .replaceAll('"scale":"Major"', '"scale":"Harmonic Minor"')
+ .replaceAll('"scale": "Major"', '"scale": "Harmonic Minor"');
+ }
+ await route.fulfill({ response, body });
+ });
+ await stubExportEndpoints(page);
+ await stubUpdateCheck(page, { available: false });
+ await page.goto("/", { waitUntil: "domcontentloaded" });
+ await page.locator(`.cat-item[data-id="${JOB_ID}"]`).first().click();
+}
+
+// Background syncs are still in flight through the rewriter when a test ends.
+test.afterEach(async ({ page }) => {
+ await page.unrouteAll({ behavior: "ignoreErrors" });
+});
+
+const EXPECTED = { en: "F# harmonic minor", de: "F# harmonisches Moll", fr: "F# mineur harmonique" };
+
+for (const [language, label] of Object.entries(EXPECTED)) {
+ for (const width of [1366, 950]) {
+ test(`${language} at ${width}px: the key is one label and it fits`, async ({ page }) => {
+ await page.setViewportSize({ width, height: 800 });
+ await openWithKey(page, { language });
+ const key = page.locator("#summary-key");
+ await expect(key).toHaveText(label);
+ await expect(page.locator('[data-meta="scale"]')).toHaveCount(0);
+ const clipped = await key.evaluate((el) => el.scrollWidth > el.clientWidth);
+ expect(clipped).toBe(false);
+ });
+ }
+}
diff --git a/tests/e2e/lyrics-cjk.spec.mjs b/tests/e2e/lyrics-cjk.spec.mjs
index c56746bc..9efd5be4 100644
--- a/tests/e2e/lyrics-cjk.spec.mjs
+++ b/tests/e2e/lyrics-cjk.spec.mjs
@@ -13,8 +13,8 @@
// lyrics-from-server.spec.mjs gives them, and the vocals envelope is absent, so
// the timing is the line's own and does not depend on the fixture's audio.
//
-// Last, the tab's own lookup (no lyrics from the server) finding a song LRCLIB
-// files only under the band's name in its own script.
+// Last, the tab asking the server to look a track up (no lyrics kept yet),
+// with the band saved in both scripts.
import { test, expect } from "@playwright/test";
import {
JOB_ID,
@@ -24,9 +24,10 @@ import {
stubAudioTags,
stubExportEndpoints,
stubUpdateCheck,
+ stubLyricsLookup,
+ LYRICS_LOOKUP,
} from "./helpers.mjs";
-const LRCLIB = /^https:\/\/lrclib\.net\//;
const WIKIMEDIA = /^https:\/\/((www|query)\.wikidata\.org|[a-z-]+\.wikipedia\.org)\//;
const LINES = {
@@ -58,18 +59,12 @@ const SERVER = {
others: [],
};
-async function setUp(page, { server = SERVER, lrclibRows = null, extra = {} } = {}) {
+async function setUp(page, { server = SERVER, extra = {} } = {}) {
+ // Lookups the tab asked the server for (#719). Watched, not answered: a test
+ // that wants an answer stubs the lookup itself.
const lrclib = [];
- await page.route(LRCLIB, (route) => {
- const url = new URL(route.request().url());
- lrclib.push(url.searchParams.get("artist_name") || `q:${url.searchParams.get("q")}`);
- if (!lrclibRows) return route.abort("internetdisconnected");
- return route.fulfill({
- status: 200,
- contentType: "application/json",
- headers: { "access-control-allow-origin": "*" },
- body: JSON.stringify(lrclibRows(url.searchParams.get("artist_name"))),
- });
+ page.on("request", (req) => {
+ if (LYRICS_LOOKUP.test(new URL(req.url()).pathname)) lrclib.push(req.url());
});
await page.route(`**/api/jobs/${JOB_ID}/lyrics`, (route) => (server
? route.fulfill({ status: 200, contentType: "application/json", body: JSON.stringify(server) })
@@ -183,19 +178,19 @@ test.describe("karaoke in Chinese, Japanese and Korean", () => {
expect(await ko.evaluate((el) => getComputedStyle(el).wordBreak)).toBe("keep-all");
});
- test("the tab finds a song LRCLIB files under the band's name in its own script", async ({ page }) => {
+ test("the tab asks the server with the band's names, and shows the song it found", async ({ page }) => {
// Tagged "Jay Chou"; LRCLIB has the song only as 周杰倫's, and the artist
- // box saved the band with both names. Another singer's 晴天 is never taken.
- const rows = (artist) => (artist === "周杰倫"
- ? [{ id: 401, trackName: "晴天", artistName: "周杰倫", albumName: "葉惠美", duration: 6, instrumental: false, syncedLyrics: SYNCED, plainLyrics: "" }]
- : [{ id: 402, trackName: "晴天", artistName: "张信哲", albumName: "", duration: 6, instrumental: false, syncedLyrics: "[00:00.50]not his", plainLyrics: "" }]);
- const { lrclib } = await setUp(page, {
+ // box saved the band with both names. Searching by the band's other names
+ // is the server's job now (#719, tests/test_lyrics_lookup.py); the tab
+ // sends the band it saved and shows what came back.
+ const rows = [{ id: 401, trackName: "晴天", artistName: "周杰倫", albumName: "葉惠美", duration: 6, instrumental: false, syncedLyrics: SYNCED, plainLyrics: "" }];
+ const asked = await stubLyricsLookup(page, { rows, artist: "周杰倫", song: "晴天" });
+ await setUp(page, {
server: null,
- lrclibRows: rows,
extra: { artist: { id: "Q238819", name: "周杰倫", englishName: "Jay Chou" } },
});
await expect(page.locator(".lyrics-line")).toHaveCount(4);
await expect(page.locator(".lyrics-match-meta")).toHaveText("周杰倫 · 葉惠美");
- expect(lrclib).toEqual(["Jay Chou", "周杰倫"]);
+ expect(asked.map((a) => a.body.band)).toEqual([{ id: "Q238819", name: "周杰倫", englishName: "Jay Chou" }]);
});
});
diff --git a/tests/e2e/lyrics-from-server.spec.mjs b/tests/e2e/lyrics-from-server.spec.mjs
index 2c902c9e..58f1cce6 100644
--- a/tests/e2e/lyrics-from-server.spec.mjs
+++ b/tests/e2e/lyrics-from-server.spec.mjs
@@ -19,9 +19,9 @@ import {
stubAudioTags,
stubExportEndpoints,
stubUpdateCheck,
+ LYRICS_LOOKUP,
} from "./helpers.mjs";
-const LRCLIB = /^https:\/\/lrclib\.net\//;
const WIKIMEDIA = /^https:\/\/((www|query)\.wikidata\.org|[a-z-]+\.wikipedia\.org)\//;
const version = (id, extra = {}) => ({
@@ -51,10 +51,12 @@ const SERVER = {
};
async function setUp(page, { server = SERVER, saved = null } = {}) {
+ // Lookups the tab asks the server for (#719), answered as LRCLIB being
+ // out of reach.
const lrclib = [];
- await page.route(LRCLIB, (route) => {
+ await page.route(LYRICS_LOOKUP, (route) => {
lrclib.push(route.request().url());
- return route.abort("internetdisconnected");
+ return route.fulfill({ status: 502, json: { detail: "lyrics service unreachable" } });
});
const served = [];
await page.route(`**/api/jobs/${JOB_ID}/lyrics`, (route) => {
@@ -208,7 +210,7 @@ test.describe("lyrics from the server", () => {
expect(lrclib).toEqual([]);
});
- test("with none on the server, the tab looks them up itself as before", async ({ page }) => {
+ test("with none on the server, the tab asks the server to look them up", async ({ page }) => {
const { lrclib, served } = await setUp(page, { server: null });
await expect.poll(() => lrclib.length).toBeGreaterThan(0);
expect(served.length).toBeGreaterThan(0);
diff --git a/tests/e2e/lyrics.spec.mjs b/tests/e2e/lyrics.spec.mjs
index e574a0dd..802a67a5 100644
--- a/tests/e2e/lyrics.spec.mjs
+++ b/tests/e2e/lyrics.spec.mjs
@@ -3,11 +3,13 @@
// them for the track, and shows them in time with playback, karaoke style.
// There is no search box.
//
-// LRCLIB is answered here, so the tests run offline. The fixture track is six
-// seconds long, which is why the synced lines below sit inside it and why the
-// first row below counts as the same recording. Ranking, LRC parsing, word
-// timing and title cleaning are covered in tests/js/lyrics-lookup.test.mjs;
-// this is the page: what is looked up and when, what is kept, what is shown.
+// The tab asks the server to look lyrics up (#719), and the server's answer is
+// given here (stubLyricsLookup), so the tests run offline. The fixture track
+// is six seconds long, which is why the synced lines below sit inside it and
+// why the first row below counts as the same recording. Which version the
+// server keeps is tested against the server in tests/test_lyrics_lookup.py,
+// LRC parsing and word timing in tests/js/lyrics-lookup.test.mjs; this is the
+// page: what is asked and when, what is kept, what is shown.
import { test, expect } from "@playwright/test";
import {
JOB_ID,
@@ -19,9 +21,11 @@ import {
stubAudioTags,
stubExportEndpoints,
stubUpdateCheck,
+ stubLyricsLookup,
+ LYRICS_LOOKUP,
} from "./helpers.mjs";
-const LRCLIB = /^https:\/\/lrclib\.net\//;
+const LRCLIB = LYRICS_LOOKUP;
const ROWS = [
{
@@ -51,20 +55,16 @@ const TAGS = { audioTags: { artist: "Fixture Band", title: "Fixture Song" } };
// The first row as another artist's or another song's, for a search that asks for those.
const rowAs = (artistName, trackName) => [{ ...ROWS[0], artistName, trackName }];
-async function stubLrclib(page, { rows = ROWS, offline = false } = {}) {
- const asked = [];
- await page.route(LRCLIB, async (route) => {
- asked.push(route.request().url());
- if (offline) return route.abort("internetdisconnected");
- return route.fulfill({
- status: 200,
- contentType: "application/json",
- headers: { "access-control-allow-origin": "*" },
- body: JSON.stringify(rows),
- });
- });
- return asked;
-}
+// The tagged artist and song unless a test says otherwise.
+const stubLrclib = (page, options = {}) =>
+ stubLyricsLookup(page, { rows: ROWS, artist: "Fixture Band", song: "Fixture Song", ...options });
+
+/** What the server kept for the fixture track, as GET .../lyrics answers. */
+const serverKept = (page) =>
+ page.evaluate(async (id) => {
+ const res = await fetch(`/api/jobs/${id}/lyrics`);
+ return res.ok ? res.json() : null;
+ }, JOB_ID);
/** Both fixture tracks, the first with `extra` fields (tags, a saved band). */
async function seedWith(page, extra) {
@@ -162,15 +162,12 @@ test.describe("lyrics tab", () => {
await expect(page.locator(".lyrics-line")).toHaveText(["First line", "Second line", "Third line"]);
await expect(page.locator(".lyrics-match-title")).toHaveText("Fixture Song");
- // What went out: the tagged artist and song, to LRCLIB, nothing else.
- expect(asked).toHaveLength(1);
- const url = new URL(asked[0]);
- expect(url.searchParams.get("artist_name")).toBe("Fixture Band");
- expect(url.searchParams.get("track_name")).toBe("Fixture Song");
- expect(asked[0]).not.toContain("E2E");
+ // One request, to the server, which looks the tags up itself (#719).
+ expect(asked).toEqual([{ id: JOB_ID, body: {} }]);
- // Kept on this machine, for this track.
- await expect.poll(async () => (await stored(page))?.entry?.id ?? null).toBe(101);
+ // Kept by the server, for this track, the way an import keeps them.
+ expect((await serverKept(page))?.lrclib_id).toBe(101);
+ expect(await stored(page)).toBeNull();
// The other version is folded away until asked for, then can be taken.
const toggle = page.locator(".lyrics-tools .lyrics-link").first();
@@ -183,15 +180,14 @@ test.describe("lyrics tab", () => {
});
test("a saved band is looked up with the song's name taken from the title", async ({ page }) => {
- const asked = await stubLrclib(page, { rows: rowAs("Dream Theater", "E2E Fixture Track") });
+ const asked = await stubLrclib(page, { rows: rowAs("Dream Theater", "E2E Fixture Track"), artist: "Dream Theater", song: "E2E Fixture Track" });
await seedWith(page, { artist: { id: "Q162586", name: "Dream Theater", englishName: "Dream Theater" } });
await open(page);
await openTrack(page);
await showLyricsTab(page);
await expect(page.locator(".lyrics-line")).toHaveCount(3);
- const url = new URL(asked[0]);
- expect(url.searchParams.get("artist_name")).toBe("Dream Theater");
- expect(url.searchParams.get("track_name")).toBe("E2E Fixture Track");
+ // The band lives in the studio's store, so it goes along with the request.
+ expect(asked[0].body.band).toEqual({ id: "Q162586", name: "Dream Theater", englishName: "Dream Theater" });
// Kept, so coming back to the tab asks nothing more.
await page.locator(".rail-library").click();
@@ -363,9 +359,10 @@ test.describe("lyrics tab", () => {
await expect(page.locator("#lyricsStatus")).toHaveText("Lyrics removed for this track.");
expect(asked).toHaveLength(1);
+ // Looking up again finds what the server kept, with nothing more asked.
await page.locator(".lyrics-link", { hasText: "Look up again" }).click();
await expect(page.locator(".lyrics-line")).toHaveCount(3);
- expect(asked).toHaveLength(2);
+ expect(asked).toHaveLength(1);
});
test("nothing found says so", async ({ page }) => {
@@ -422,15 +419,15 @@ test.describe("lyrics tab", () => {
});
test("a tagged artist with no tagged title is looked up with the song from the title", async ({ page }) => {
- const asked = await stubLrclib(page, { rows: rowAs("Fixture Band", "E2E Fixture Track") });
+ // The server takes the song from the title (build_query); the page only
+ // has to ask, which it does even with no tagged title.
+ const asked = await stubLrclib(page, { rows: rowAs("Fixture Band", "E2E Fixture Track"), song: "E2E Fixture Track" });
await seedWith(page, { audioTags: { artist: "Fixture Band" } });
await open(page);
await openTrack(page);
await showLyricsTab(page);
await expect(page.locator(".lyrics-line")).toHaveCount(3);
- const url = new URL(asked[0]);
- expect(url.searchParams.get("artist_name")).toBe("Fixture Band");
- expect(url.searchParams.get("track_name")).toBe("E2E Fixture Track");
+ expect(asked).toHaveLength(1);
});
test("another artist's song of the same name is not this track's lyrics", async ({ page }) => {
diff --git a/tests/e2e/search.spec.mjs b/tests/e2e/search.spec.mjs
index 7c01c51d..6ea0f0ff 100644
--- a/tests/e2e/search.spec.mjs
+++ b/tests/e2e/search.spec.mjs
@@ -150,7 +150,7 @@ test.describe("topbar search", () => {
await expect(page.locator("#url")).toHaveValue(/youtube\.com\/watch\?v=/);
await expect(panel(page)).toBeHidden();
- // Extraction is minutes of work. It waits for Split stems.
+ // Extraction is minutes of work. It waits for Extract stems.
expect(jobPosts).toHaveLength(0);
});
diff --git a/tests/e2e/slow-speed.spec.mjs b/tests/e2e/slow-speed.spec.mjs
new file mode 100644
index 00000000..3143c6f3
--- /dev/null
+++ b/tests/e2e/slow-speed.spec.mjs
@@ -0,0 +1,70 @@
+// The slow speed is the player's to set (#701).
+//
+// Speed was a fixed 0.75x or 1x. Some fills want 0.75x and some only a nudge,
+// so the slow button can be moved a hundredth at a time, by the wheel or the
+// up and down arrow keys, between 0.50x and 0.99x, and it is remembered.
+
+import { test, expect } from "@playwright/test";
+import { openStudio } from "./helpers.mjs";
+
+const slow = (page) => page.locator("#t-speed-075");
+const rate = (page) => page.evaluate(async () => (await import("/js/state.js")).playbackSpeed);
+
+test("scrolling over the slow button moves it a hundredth at a time and plays at it", async ({ page }) => {
+ await openStudio(page);
+ await expect(slow(page)).toHaveText("0.75x");
+ await slow(page).hover();
+ await page.mouse.wheel(0, -100);
+ await page.mouse.wheel(0, -100);
+ await expect(slow(page)).toHaveText("0.77x");
+ await expect(slow(page)).toHaveAttribute("aria-checked", "true");
+ await expect.poll(() => rate(page)).toBe(0.77);
+
+ // 1x is still one press away, and the slow speed is kept for next time.
+ await page.locator("#t-speed-1").click();
+ await expect.poll(() => rate(page)).toBe(1);
+ await slow(page).click();
+ await expect.poll(() => rate(page)).toBe(0.77);
+});
+
+test("the arrow keys move it too, and it stops at 0.50x and 0.99x", async ({ page }) => {
+ await openStudio(page);
+ await slow(page).focus();
+ for (let i = 0; i < 40; i++) await page.keyboard.press("ArrowDown");
+ await expect(slow(page)).toHaveText("0.50x");
+ for (let i = 0; i < 60; i++) await page.keyboard.press("ArrowUp");
+ await expect(slow(page)).toHaveText("0.99x");
+ await expect.poll(() => rate(page)).toBe(0.99);
+});
+
+test("the slow speed survives a reload", async ({ page }) => {
+ await openStudio(page);
+ await slow(page).hover();
+ await page.mouse.wheel(0, 100);
+ await expect(slow(page)).toHaveText("0.74x");
+ await page.waitForTimeout(400);
+ await page.reload({ waitUntil: "domcontentloaded" });
+ await expect(slow(page)).toHaveText("0.74x");
+ // A track opens at normal speed, as it always has.
+ await expect(page.locator("#t-speed-1")).toHaveAttribute("aria-checked", "true");
+});
+
+test("half speed is one press, and never lights with a slow speed set to 0.50x", async ({ page }) => {
+ await openStudio(page);
+ const half = page.locator("#t-speed-05");
+ await expect(half).toHaveText("0.5x");
+ await half.click();
+ await expect.poll(() => rate(page)).toBe(0.5);
+ await expect(half).toHaveAttribute("aria-checked", "true");
+ await expect(slow(page)).toHaveAttribute("aria-checked", "false");
+
+ // The slow speed brought down to the same 0.50x: only the button pressed is lit.
+ await slow(page).focus();
+ for (let i = 0; i < 25; i++) await page.keyboard.press("ArrowDown");
+ await expect(slow(page)).toHaveText("0.50x");
+ await expect(slow(page)).toHaveAttribute("aria-checked", "true");
+ await expect(half).toHaveAttribute("aria-checked", "false");
+
+ await page.locator("#t-speed-1").click();
+ await expect.poll(() => rate(page)).toBe(1);
+});
diff --git a/tests/e2e/tempo-stage.spec.mjs b/tests/e2e/tempo-stage.spec.mjs
new file mode 100644
index 00000000..bb412935
--- /dev/null
+++ b/tests/e2e/tempo-stage.spec.mjs
@@ -0,0 +1,42 @@
+// The Signalsmith tempo stage loads in a real browser (#729).
+//
+// tests/js/signalsmith-stage.test.mjs checks the stage itself in node. What
+// only a browser can show is that it gets that far at all: the core is a
+// WebAssembly module compiled inside the audio worklet, which the page's CSP
+// blocks unless script-src allows 'wasm-unsafe-eval'. Blocked, the processor
+// quietly keeps WSOLA and every other test still passes, so this watches the
+// processor say which stage it is running.
+
+import { test, expect } from "@playwright/test";
+import { openStudio } from "./helpers.mjs";
+
+async function recordWorkletMessages(page) {
+ await page.addInitScript(() => {
+ window.__workletMessages = [];
+ const Native = window.AudioWorkletNode;
+ window.AudioWorkletNode = class extends Native {
+ constructor(...args) {
+ super(...args);
+ this.port.addEventListener("message", (event) => window.__workletMessages.push(event.data));
+ }
+ };
+ });
+}
+
+test("slowed playback runs on the Signalsmith stage", async ({ page }) => {
+ const failures = [];
+ page.on("console", (msg) => {
+ if (msg.type() === "warning" && msg.text().includes("[tempoStage]")) failures.push(msg.text());
+ });
+ await recordWorkletMessages(page);
+ await openStudio(page);
+
+ await page.locator("#t-speed-075").click();
+ await page.locator("#t-play").click();
+
+ await expect.poll(
+ () => page.evaluate(() => window.__workletMessages.filter((m) => m?.type === "tempoStage").at(-1)?.stage),
+ { timeout: 10000 },
+ ).toBe("signalsmith");
+ expect(failures).toEqual([]);
+});
diff --git a/tests/js/key-label.test.mjs b/tests/js/key-label.test.mjs
new file mode 100644
index 00000000..10afc7b2
--- /dev/null
+++ b/tests/js/key-label.test.mjs
@@ -0,0 +1,61 @@
+// The merged key label (#736): "B minor", not "B min" plus "Natural Minor" plus
+// a Scale card saying it a third time.
+//
+// Run: node tests/js/key-label.test.mjs
+
+import { formatKey } from '../../static/js/keyLabel.js';
+import { TRANSLATIONS } from '../../static/js/i18n.js';
+
+let passed = 0;
+let failed = 0;
+
+function check(name, condition, detail = '') {
+ if (condition) {
+ passed++;
+ console.log(`PASS ${name}`);
+ } else {
+ failed++;
+ console.log(`FAIL ${name}${detail ? ` -- ${detail}` : ''}`);
+ }
+}
+
+// The same lookup the app does: the language, then pt for pt-PT, then English.
+const FALLBACK = { 'pt-PT': 'pt' };
+function tFor(code) {
+ return (key, vars = {}) => {
+ let text;
+ for (let c = code; c && text === undefined; c = FALLBACK[c]) text = TRANSLATIONS[c]?.[key];
+ text ??= TRANSLATIONS.en[key] ?? key;
+ return text.replace(/\{(\w+)\}/g, (_, v) => String(vars[v] ?? `{${v}}`));
+ };
+}
+const en = tFor('en');
+
+check('a major key reads as one label', formatKey('D maj', 'Major', en) === 'D major', formatKey('D maj', 'Major', en));
+check('a natural minor key drops "natural"', formatKey('B min', 'Natural Minor', en) === 'B minor');
+check('harmonic minor is named', formatKey('B min', 'Harmonic Minor', en) === 'B harmonic minor');
+check('sharps keep their letter', formatKey('F# min', 'Natural Minor', en) === 'F# minor');
+check('a track analysed before scale was stored still reads', formatKey('F# min', undefined, en) === 'F# minor');
+check('an unknown scale falls back on the key', formatKey('C maj', 'Dorian', en) === 'C major');
+check('an unreadable key is shown as stored', formatKey('weird', null, en) === 'weird');
+check('no key gives nothing', formatKey(null, 'Major', en) === '' && formatKey('', null, en) === '');
+
+// Every language, including the regional variant, produces a complete label:
+// the tonic letter, no raw key names, no unfilled placeholder.
+for (const code of Object.keys(TRANSLATIONS)) {
+ const t = tFor(code);
+ for (const scale of ['Major', 'Natural Minor', 'Harmonic Minor']) {
+ const label = formatKey('F# min', scale, t);
+ check(
+ `${code}: ${scale} is a complete label`,
+ label.startsWith('F#') && !/key\.|\{|\}/.test(label) && label.length > 3,
+ label,
+ );
+ }
+}
+
+check('German reads naturally', formatKey('B min', 'Natural Minor', tFor('de')) === 'B Moll');
+check('European Portuguese keeps its spelling', formatKey('B min', 'Harmonic Minor', tFor('pt-PT')) === 'B menor harmónica');
+
+console.log(`\n${passed}/${passed + failed} checks passed`);
+process.exit(failed === 0 ? 0 : 1);
diff --git a/tests/js/lyrics-lookup.test.mjs b/tests/js/lyrics-lookup.test.mjs
index 31173f7c..cb7eb74f 100644
--- a/tests/js/lyrics-lookup.test.mjs
+++ b/tests/js/lyrics-lookup.test.mjs
@@ -1,30 +1,20 @@
-// The Lyrics tab's lookup (#699): how LRC text becomes timed lines, which line
-// is being sung at a given moment, which of LRCLIB's many versions of a song
-// is taken as the one, and what is sent to search for it.
-//
-// No network. searchLyrics takes its fetch as an argument.
+// The Lyrics tab's reading of lyrics (#699): how LRC text becomes timed lines,
+// which line is being sung at a given moment, and what the server's answer
+// becomes. Which of LRCLIB's versions is the track's is the server's to decide
+// (#719), and is tested in tests/test_lyrics_lookup.py.
//
// Run: node tests/js/lyrics-lookup.test.mjs
import {
parseLrc,
currentLineIndex,
- rankMatches,
- searchUrl,
- searchLyrics,
wordTimings,
voicedPhrases,
syllables,
songFromTitle,
fromServerLyrics,
- strippedCopy,
- belongsTo,
- sameArtist,
sameSong,
- scriptNames,
- otherNames,
fold as foldName,
- rankVersions,
clampOffset,
shiftLines,
firstSungIndex,
@@ -208,66 +198,6 @@ check("between lines, the one before", currentLineIndex(lines, 25) === 1);
check("after the last", currentLineIndex(lines, 99) === 2);
check("no lines", currentLineIndex([], 5) === -1);
-// ── rankMatches ──
-const row = (id, duration, kind) => ({
- id,
- trackName: `T${id}`,
- artistName: "A",
- albumName: "",
- duration,
- instrumental: kind === "instrumental",
- syncedLyrics: kind === "synced" ? "[00:01.00]x" : null,
- plainLyrics: kind === "synced" || kind === "plain" ? "x" : null,
-});
-const ranked = rankMatches(
- [row(1, 769, "synced"), row(2, 571, "plain"), row(3, 573, "synced"), row(4, 572, "none"), row(5, 590, "synced")],
- 572,
-);
-check(
- "closest length first, synced preferred within a few seconds, empty rows dropped",
- same(ranked.map((m) => m.id), [3, 2, 5, 1]),
- JSON.stringify(ranked.map((m) => m.id)),
-);
-check("an instrumental row is kept", rankMatches([row(9, 100, "instrumental")], 100).length === 1);
-check(
- "with no length known, LRCLIB's order, synced first",
- same(rankMatches([row(1, 10, "plain"), row(2, 500, "synced")], 0).map((m) => m.id), [2, 1]),
-);
-check("not an array gives nothing", same(rankMatches(null), []) && same(rankMatches({ error: 1 }), []));
-
-// ── searchUrl ──
-const withArtist = new URL(searchUrl({ artist: " Dream Theater ", song: " Metropolis " }));
-check("LRCLIB's search", withArtist.origin + withArtist.pathname === "https://lrclib.net/api/search");
-check(
- "artist and song as their own fields, trimmed",
- withArtist.searchParams.get("artist_name") === "Dream Theater" && withArtist.searchParams.get("track_name") === "Metropolis",
-);
-const songOnly = new URL(searchUrl({ song: "Metropolis" }));
-check(
- "no artist: the free-text search, not an empty artist filter",
- songOnly.searchParams.get("q") === "Metropolis" && !songOnly.searchParams.has("artist_name"),
-);
-
-// ── searchLyrics ──
-const asked = [];
-const found = await searchLyrics(
- { artist: "Dream Theater", song: "Metropolis", duration: 572 },
- { fetchJson: async (url) => { asked.push(url); return [row(1, 769, "synced"), row(3, 573, "synced")]; } },
-);
-check("ranked for the track's length", same(found.map((m) => m.id), [3, 1]));
-check("one request, to LRCLIB only", asked.length === 1 && asked[0].startsWith("https://lrclib.net/"));
-check(
- "no song asks nothing",
- same(await searchLyrics({ artist: "X", song: " " }, { fetchJson: () => { throw new Error("asked"); } }), []),
-);
-let rejected = false;
-try {
- await searchLyrics({ song: "x" }, { fetchJson: async () => { throw new Error("offline"); } });
-} catch {
- rejected = true;
-}
-check("no connection rejects, rather than reading as nothing found", rejected);
-
// ── fromServerLyrics: lyrics.json from GET /api/jobs/{id}/lyrics ──
const version = (id, source = "lrclib", extra = {}) => ({
v: 1,
@@ -319,70 +249,6 @@ check(
);
// ── letters outside ASCII ──
-// LRCLIB holds some songs as copies that lost those letters on the way in
-// (Kayah's "Nie ma, nie ma ciebie": eleven copies read "Niewinnoci biaym
-// niegiem", one "Niewinnością białym śniegiem"). The anthem stands in for a
-// song, being in the public domain. The same cases as tests/test_lyrics_lookup.py.
-const ANTHEM = [
- "[00:01.00]Jeszcze Polska nie zginęła,",
- "[00:04.00]Kiedy my żyjemy.",
- "[00:07.00]Co nam obca przemoc wzięła,",
- "[00:10.00]Szablą odbierzemy.",
- "[00:13.00]Marsz, marsz, Dąbrowski,",
- "[00:16.00]Z ziemi włoskiej do Polski.",
- "[00:19.00]Za twoim przewodem",
- "[00:22.00]Złączym się z narodem.",
-].join("\n");
-const drop = (s) => s.replace(/[^\p{ASCII}]/gu, "");
-const fold = (s) => drop(s.normalize("NFD"));
-const asLrclibDropsThem = (s) => drop(s.replaceAll("ę", "e"));
-const textRow = (id, duration, text, synced = true) => ({
- id,
- trackName: `T${id}`,
- artistName: "A",
- albumName: "",
- duration,
- instrumental: false,
- syncedLyrics: synced ? text : null,
- plainLyrics: text.replace(/\[[^\]\n]*\]/g, ""),
-});
-const lyricsOf = (text) => ({ synced: text, plain: "" });
-
-for (const [name, strip] of [["dropped", drop], ["folded", fold], ["as LRCLIB drops them", asLrclibDropsThem]]) {
- check(`a copy whose Polish letters were ${name} is told from its source`, strippedCopy(lyricsOf(strip(ANTHEM)), lyricsOf(ANTHEM)));
-}
-check("the intact copy is not a stripped one", !strippedCopy(lyricsOf(ANTHEM), lyricsOf(asLrclibDropsThem(ANTHEM))));
-check("a copy is not a stripped copy of itself", !strippedCopy(lyricsOf(ANTHEM), lyricsOf(ANTHEM)));
-for (const [intact, other] of [
- ["[00:01.00]Группа крови на рукаве, мой порядковый номер на рукаве", "[00:01.00]Gruppa krovi na rukave, moy poryadkovyy nomer na rukave"],
- ["[00:01.00]夢ならばどれほどよかったでしょう 未だにあなたのことを夢にみる", "[00:01.00]Yume naraba dore hodo yokatta deshou imada ni anata no koto wo yume ni miru"],
- ["[00:01.00]A café, a naïve smile, and the rest in plain English words", "[00:01.00]A cafe, a naive smile, and the rest in plain English words"],
- [ANTHEM, "[00:01.00]Jeszcze nic nie jest stracone, moja mila, gdy jestem z toba"],
-]) {
- check(
- `not a stripped copy: ${other.slice(10, 30)}`,
- !strippedCopy(lyricsOf(other), lyricsOf(intact)) && !strippedCopy(lyricsOf(intact), lyricsOf(other)),
- );
-}
-{
- const rows = [
- textRow(5470091, 230, asLrclibDropsThem(ANTHEM)),
- textRow(28700266, 230, asLrclibDropsThem(ANTHEM)),
- textRow(10910419, 229.93, ANTHEM),
- textRow(4291789, 230, ANTHEM, false),
- ];
- const want = [10910419, 5470091, 28700266, 4291789];
- check("the intact copy ranks before stripped ones LRCLIB listed first", same(rankMatches(rows, 230).map((m) => m.id), want));
- check("and with the length unknown", same(rankMatches(rows).map((m) => m.id), want));
- const stripped = textRow(1, 230, asLrclibDropsThem(ANTHEM));
- check(
- "synced still beats plain, and length beats both",
- same(rankMatches([stripped, textRow(2, 230, ANTHEM, false)], 230).map((m) => m.id), [1, 2])
- && same(rankMatches([stripped, textRow(3, 250, ANTHEM)], 230).map((m) => m.id), [1, 3]),
- );
-}
-
-// Polish through parsing and the wipe: nothing dropped, nothing split.
{
const polish = parseLrc("[00:31.72]<00:31.72>Śpiewałem <00:32.40>głośno <00:32.90>pod <00:33.10>prysznicem\n[00:33.97]Ten mój małomiasteczkowy hit");
check("Polish lines keep every letter", polish[0].text === "Śpiewałem głośno pod prysznicem" && polish[1].text === "Ten mój małomiasteczkowy hit");
@@ -403,52 +269,17 @@ for (const [intact, other] of [
check("Cyrillic words stay whole", same(cyrillic.map((w) => w.text), ["Группа ", "крови ", "на ", "рукаве"]));
}
-// Whose song a version is: only this song by this artist is ever kept.
+// Whose song kept lyrics are: the check on what the tab kept before the
+// server held versions to the track's song (#719). The rest of the rule is
+// the server's alone (tests/test_lyrics_lookup.py).
{
- const ask = { artist: "Keala Settle & The Greatest Showman Ensemble", song: "This Is Me" };
- const row = (artist, track) => ({ artist, track });
- check("the same artist and song belong", belongsTo(row("Keala Settle & The Greatest Showman Ensemble", "This Is Me"), ask));
- check("one credited artist belongs", belongsTo(row("Keala Settle", "This Is Me"), ask));
- check("the cast filed as a run of the name belongs", belongsTo(row("The Greatest Showman Ensemble", "This Is Me"), ask));
- check("a song tail belongs", belongsTo(row("Keala Settle", "This Is Me - From The Greatest Showman"), ask));
check("brackets and featuring are ignored", sameSong("This Is Me (feat. Someone) [Live]", "This Is Me"));
- check("another artist's song of that name does not", !belongsTo(row("Kesha", "This Is Me"), ask));
- check("the artist's other song does not", !belongsTo(row("Keala Settle", "This Is Not Me"), ask));
+ check("a song tail belongs", sameSong("This Is Me - From The Greatest Showman", "This Is Me"));
+ check("another song is not this one", !sameSong("This Is Not Me", "This Is Me"));
check("two different tails are two songs", !sameSong("Part I - Dawn", "Part I - Dusk"));
- check("no artist known, nothing belongs", !belongsTo(row("Keala Settle", "This Is Me"), { artist: "", song: "This Is Me" }));
- check("a show's name counts when given", belongsTo(row("Wicked", "Popular"), { artist: "Kristin Chenoweth", song: "Popular", names: ["Wicked"] }));
- check("a show's name does not count unless given", !belongsTo(row("Wicked", "Popular"), { artist: "Kristin Chenoweth", song: "Popular" }));
- check("case, accents and a leading The do not matter", sameArtist("the beatles", ["The Beatles"]) && sameArtist("Beyonce", ["Beyoncé"]) && sameArtist("Beatles", ["The Beatles"]));
- check("Polish names compare letter for letter", sameArtist("Dawid Podsiadło", ["Dawid Podsiadło"]) && !sameArtist("Dawid Podsiadło", ["Dawid Kwiatkowski"]));
- check("a two-letter credit names nobody", !sameArtist("DJ", ["DJ & Someone Else"]));
- check("one shared word is not a shared name", !sameArtist("Pink", ["Pink Floyd"]));
}
-// Chinese, Japanese and Korean names: the cases in tests/test_lyrics_names.py.
{
- const artists = [
- ["周杰伦", ["周杰倫"], true],
- ["邓丽君", ["鄧麗君"], true],
- ["ＹＯＡＳＯＢＩ", ["YOASOBI"], true],
- ["ｷﾝｸﾞﾇｰ", ["キングヌー"], true],
- ["Dawid Podsiadlo", ["Dawid Podsiadło"], true],
- ["鄧麗君 (Teresa Teng)", ["Teresa Teng"], true],
- ["五月天 (Mayday)", ["五月天"], true],
- ["IU", ["IU (아이유)"], true],
- ["周杰倫", ["周杰倫 Jay Chou"], true],
- ["Jay Chou", ["周杰倫 Jay Chou"], true],
- ["周杰倫 & 費玉清", ["周杰倫"], true],
- ["Jay Chou", ["周杰倫"], false],
- ["아이유", ["IU"], false],
- ["张信哲", ["周杰倫"], false],
- ["五月天 阿信", ["五月天"], false],
- ["告五人", ["五月天"], false],
- ["Official", ["Official髭男dism"], false],
- ["林", ["林 & 周杰倫"], false],
- ];
- for (const [found, names, want] of artists) {
- check(`sameArtist(${found}, ${names}) is ${want}`, sameArtist(found, names) === want);
- }
const songs = [
["红豆", "紅豆", true],
["晴天 (Sunny Day)", "晴天", true],
@@ -465,20 +296,7 @@ for (const [intact, other] of [
for (const [found, song, want] of songs) {
check(`sameSong(${found}, ${song}) is ${want}`, sameSong(found, song) === want);
}
- check("a name in two scripts gives both", same(scriptNames("周杰倫 Jay Chou"), ["周杰伦", "Jay Chou"]) && same(scriptNames("IU(아이유)"), ["IU", "아이유"]));
- check("a name mixing scripts in one word is one name", same(scriptNames("Official髭男dism"), []) && same(scriptNames("五月天 阿信"), []));
check("folding: traditional, width, plain Latin", foldName("鄧麗君 ＩＵ Podsiadło") === "邓丽君 IU Podsiadlo");
- check("the band's names count as the artist's", belongsTo({ artist: "周杰倫", track: "晴天" }, { artist: "Jay Chou", song: "晴天", names: ["周杰倫", "Jay Chou"] }));
- check("and never make another artist's song the track's", !belongsTo({ artist: "张信哲", track: "晴天" }, { artist: "Jay Chou", song: "晴天", names: ["周杰倫"] }));
- check(
- "other names to search by: a name's own scripts, then the band's, each once",
- same(otherNames("周杰倫 Jay Chou", ["周杰倫", "Jay Chou", "周杰倫 Jay Chou"]), ["周杰伦", "Jay Chou", "周杰倫"]),
- JSON.stringify(otherNames("周杰倫 Jay Chou", ["周杰倫", "Jay Chou"])),
- );
- check("the artist's own name is not searched again", same(otherNames("IU", ["IU", "아이유"]), ["아이유"]));
- const a = rankMatches([row(1, 300, "synced"), row(2, 269, "synced")], 269);
- const b = rankMatches([row(3, 270, "synced"), row(2, 269, "synced")], 269);
- check("versions from two searches rank together, each once", same(rankVersions([...a, ...b], 269).map((m) => m.id), [2, 3, 1]));
}
// Karaoke in Chinese, Japanese and Korean.
diff --git a/tests/js/name-parity.test.mjs b/tests/js/name-parity.test.mjs
index 854a0a05..47a9694e 100644
--- a/tests/js/name-parity.test.mjs
+++ b/tests/js/name-parity.test.mjs
@@ -1,6 +1,8 @@
-// JS half of the name parity gate: the page's lyrics matching
-// (static/js/lyricsLookup.js, zhVariants.js) held to what the server's
-// (app/pipeline/lyrics_lookup.py, name_aliases.py, zh_variants.py) says.
+// JS half of the name parity gate: what is left of the page's name
+// handling (static/js/lyricsLookup.js fold and sameSong, zhVariants.js) held
+// to what the server's (app/pipeline/lyrics_lookup.py, name_aliases.py,
+// zh_variants.py) says. The page no longer decides whose song a version is
+// (#719); sameSong only checks lyrics it kept before that rule existed.
//
// tests/fixtures/name_parity.json is generated from Python and asserted by
// tests/test_name_parity.py; this file asserts the page gives the same
@@ -14,7 +16,7 @@
// Run: node tests/js/name-parity.test.mjs
import { readFileSync } from 'node:fs';
-import { fold, scriptNames, sameArtist, sameSong } from '../../static/js/lyricsLookup.js';
+import { fold, sameSong } from '../../static/js/lyricsLookup.js';
import { PAIRS, toSimplified } from '../../static/js/zhVariants.js';
const fixture = JSON.parse(readFileSync(new URL('../fixtures/name_parity.json', import.meta.url), 'utf8'));
@@ -31,22 +33,12 @@ function check(name, condition, detail = '') {
}
}
-const same = (a, b) => JSON.stringify(a) === JSON.stringify(b);
-
-check('the fixture is not empty', fixture.fold.length >= 10 && fixture.sameArtist.length >= 20 && fixture.sameSong.length >= 10);
+check('the fixture is not empty', fixture.fold.length >= 10 && fixture.sameSong.length >= 10);
for (const { in: text, out } of fixture.fold) {
const got = fold(text);
check(`fold(${JSON.stringify(text)})`, got === out, `page ${JSON.stringify(got)}, server ${JSON.stringify(out)}`);
}
-for (const { in: name, out } of fixture.scriptNames) {
- const got = scriptNames(name);
- check(`scriptNames(${JSON.stringify(name)})`, same(got, out), `page ${JSON.stringify(got)}, server ${JSON.stringify(out)}`);
-}
-for (const { found, names, same: want } of fixture.sameArtist) {
- const got = sameArtist(found, names);
- check(`sameArtist(${JSON.stringify(found)}, ${JSON.stringify(names)})`, got === want, `page ${got}, server ${want}`);
-}
for (const { found, song, same: want } of fixture.sameSong) {
const got = sameSong(found, song);
check(`sameSong(${JSON.stringify(found)}, ${JSON.stringify(song)})`, got === want, `page ${got}, server ${want}`);
diff --git a/tests/js/pitch-shift.test.mjs b/tests/js/pitch-shift.test.mjs
index 91d64423..ba47f468 100644
--- a/tests/js/pitch-shift.test.mjs
+++ b/tests/js/pitch-shift.test.mjs
@@ -619,7 +619,7 @@ const Proc = load();
const starved = load(SRC
.replace('const PRIME_CUSHION = 512;', 'const PRIME_CUSHION = 0;')
.replace('const OUTPUT_RESERVE = 512;', 'const OUTPUT_RESERVE = 0;')
- .replace('this._commonPrime = this._tempo.needed + PRIME_CUSHION;', 'this._commonPrime = 0;'));
+ .replace('this._commonPrime = this._wsola.needed + PRIME_CUSHION;', 'this._commonPrime = 0;'));
let starvedPartials = 0;
for (const [pitch, tempo] of [[2, 1], [-2, 1], [5, 1], [-5, 1]]) {
starvedPartials += artefacts(starved, pitch, tempo).partial;
diff --git a/tests/js/signalsmith-stage.test.mjs b/tests/js/signalsmith-stage.test.mjs
new file mode 100644
index 00000000..9be327dc
--- /dev/null
+++ b/tests/js/signalsmith-stage.test.mjs
@@ -0,0 +1,166 @@
+// The Signalsmith tempo stage (#729).
+//
+// WSOLA slowed audio by repeating overlapping fragments, heard as an echo on
+// everything sustained. The processor now stretches with Signalsmith Stretch
+// when its core loads, and keeps WSOLA when it does not. Checked here, with the
+// processor driven exactly as an AudioWorklet drives it:
+//
+// - the stage is swapped in at a flush, and reported, and only then
+// - the latency the engines compute from that report is the latency measured
+// - kicks come out once each and on time, so nothing drifts
+// - with no core, WSOLA stays, so playback never depends on WebAssembly
+//
+// Run: node tests/js/signalsmith-stage.test.mjs
+
+import { readFileSync } from 'node:fs';
+import { pipelineLatencySeconds } from '../../static/js/tempoStage.js';
+
+const BLOCK = 128;
+const INPUT_COUNT = 13;
+const ZERO_INPUT = 6;
+
+let passed = 0;
+let failed = 0;
+
+function check(name, condition, detail = '') {
+ if (condition) {
+ passed++;
+ console.log(`PASS ${name}`);
+ } else {
+ failed++;
+ console.log(`FAIL ${name}${detail ? ` -- ${detail}` : ''}`);
+ }
+}
+
+const vendor = (name) => readFileSync(new URL(`../../static/vendor/${name}`, import.meta.url), 'utf8');
+const PROCESSOR = vendor('soundtouch-processor.js');
+const CORE = vendor('signalsmith-stretch.js');
+
+/** A processor, with or without the core in its global scope, and its messages. */
+async function create(sr, { core }) {
+ if (core) new Function(CORE)();
+ else delete globalThis.SignalsmithStretchCore;
+ let Cls = null;
+ const messages = [];
+ new Function('sampleRate', 'AudioWorkletProcessor', 'registerProcessor', PROCESSOR)(
+ sr,
+ class { constructor() { this.port = { postMessage: (m) => messages.push(m) }; } },
+ (_name, c) => { Cls = c; },
+ );
+ const p = new Cls();
+ // Instantiating the core is asynchronous; the engine's play() resets the
+ // processor well after that, which is what this stands in for.
+ await new Promise((resolve) => setTimeout(resolve, 50));
+ p.port.onmessage({ data: { type: 'reset' } });
+ return { p, messages };
+}
+
+/** Run `input` through at `tempo` into the unpitched input; returns the left output. */
+function run(p, input, tempo, outLength) {
+ const out = new Float32Array(Math.ceil(outLength / BLOCK) * BLOCK);
+ const params = { tempo: new Float32Array([tempo]) };
+ for (let pos = 0; pos < out.length; pos += BLOCK) {
+ const block = new Float32Array(BLOCK);
+ if (pos < input.length) block.set(input.subarray(pos, Math.min(pos + BLOCK, input.length)));
+ const inputs = Array.from({ length: INPUT_COUNT }, (_, k) => (k === ZERO_INPUT ? [block, block] : []));
+ const l = new Float32Array(BLOCK);
+ p.process(inputs, [[l, new Float32Array(BLOCK)]], params);
+ out.set(l, pos);
+ }
+ return out;
+}
+
+const lastOf = (messages, type) => messages.filter((m) => m.type === type).at(-1);
+
+// --- the stage is swapped in, and says so ---
+{
+ const { p, messages } = await create(44100, { core: true });
+ run(p, new Float32Array(BLOCK), 0.75, BLOCK);
+ const stage = lastOf(messages, 'tempoStage');
+ check('the core is swapped in at the first flush', stage?.stage === 'signalsmith', `stage ${stage?.stage}`);
+ check('its latency is reported in two parts', stage?.inputFrames > 0 && stage?.outputFrames > 0);
+}
+
+// --- no core: WSOLA stays ---
+{
+ const { p, messages } = await create(44100, { core: false });
+ run(p, new Float32Array(BLOCK), 0.75, BLOCK);
+ check('without the core, WSOLA stays the tempo stage', lastOf(messages, 'tempoStage')?.stage === 'wsola');
+}
+
+// --- latency: what the engines compute is what comes out ---
+for (const sr of [44100, 48000]) {
+ for (const tempo of [0.75, 0.9]) {
+ const { p, messages } = await create(sr, { core: true });
+ const at = Math.round(sr * 0.5);
+ const input = new Float32Array(sr);
+ input[at] = 1;
+ const out = run(p, input, tempo, sr * 2);
+ let peak = 0;
+ let peakAt = 0;
+ for (let i = 0; i < out.length; i++) if (Math.abs(out[i]) > peak) { peak = Math.abs(out[i]); peakAt = i; }
+ const measured = (peakAt - at / tempo) / sr;
+ const computed = pipelineLatencySeconds({
+ workletFrames: lastOf(messages, 'latency').frames,
+ stage: lastOf(messages, 'tempoStage'),
+ rate: tempo,
+ transposed: false,
+ sampleRate: sr,
+ });
+ const error = Math.abs(measured - computed) * 1000;
+ check(
+ `the computed latency matches at ${sr} Hz, ${tempo}x`,
+ error <= 1,
+ `measured ${(measured * 1000).toFixed(1)} ms, computed ${(computed * 1000).toFixed(1)} ms`,
+ );
+ }
+}
+
+// --- kicks come out once, and on time ---
+{
+ const sr = 44100;
+ const tempo = 0.75;
+ const kicks = 40;
+ const every = 0.5;
+ const n = Math.round((kicks * every + 0.5) * sr);
+ const x = new Float32Array(n);
+ for (let i = 0; i < n; i++) {
+ const t = i / sr;
+ x[i] = 0.08 * (Math.sin(2 * Math.PI * 220 * t) + Math.sin(2 * Math.PI * 261.63 * t) + Math.sin(2 * Math.PI * 329.63 * t));
+ }
+ for (let k = 0; k < kicks; k++) {
+ const at = Math.round((0.25 + k * every) * sr);
+ for (let i = 0; i < 0.15 * sr && at + i < n; i++) {
+ const t = i / sr;
+ const click = t < 0.003 ? 0.5 * Math.sin(2 * Math.PI * 3000 * t) * (1 - t / 0.003) : 0;
+ x[at + i] += click + 0.6 * Math.sin(2 * Math.PI * 60 * t) * Math.exp(-t / 0.04);
+ }
+ }
+ const { p } = await create(sr, { core: true });
+ const y = run(p, x, tempo, Math.round(n / tempo) + sr);
+
+ // Peaks of the click band's 1 ms envelope above a third of the loudest.
+ const hop = Math.round(sr * 0.001);
+ const env = [];
+ for (let i = hop; i + hop <= y.length; i += hop) {
+ let e = 0;
+ for (let j = 0; j < hop; j++) e += (y[i + j] - y[i + j - 1]) ** 2;
+ env.push(e);
+ }
+ const top = Math.max(...env);
+ const found = [];
+ for (let f = 1; f + 1 < env.length; f++) {
+ if (env[f] < top / 3 || env[f] < env[f - 1] || env[f] < env[f + 1]) continue;
+ const t = (f + 1) * hop / sr;
+ if (found.length && t - found.at(-1) < 0.01) continue;
+ found.push(t);
+ }
+ check(`every kick comes out once at ${tempo}x`, found.length === kicks, `heard ${found.length} for ${kicks}`);
+ // The input advance carries its fraction, so the last kick lands where an
+ // exact clock puts it, not a few samples further each quantum.
+ const drift = found.at(-1) - found[0] - ((kicks - 1) * every) / tempo;
+ check('the last kick is on the clock', Math.abs(drift) <= 0.002, `${(drift * 1000).toFixed(2)} ms`);
+}
+
+console.log(`\n${passed}/${passed + failed} checks passed`);
+process.exit(failed === 0 ? 0 : 1);
diff --git a/tests/js/slowed-scheduling.test.mjs b/tests/js/slowed-scheduling.test.mjs
new file mode 100644
index 00000000..3dd6553c
--- /dev/null
+++ b/tests/js/slowed-scheduling.test.mjs
@@ -0,0 +1,198 @@
+// Slowed playback must never let the chunk sources run dry (#722).
+//
+// With SoundTouch stretching, sources play at 1x and the worklet buffers what
+// it has not yet released, so below 1x the sources are used up faster than the
+// output playhead moves. The lookahead gate compared against the output
+// playhead, overstated its margin by (1 - rate) seconds every second, and at
+// 0.75x the sources ran dry about fifty seconds in.
+//
+// So this plays a two minute track against a fake clock, one tick every 100 ms,
+// and checks at every tick that the scheduled sources still reach past "now".
+// The bug needs minutes of playback to show, which the 6 second e2e fixture
+// cannot provide, hence a node test with a synthetic WAV.
+
+let passed = 0;
+let failed = 0;
+
+function check(name, condition, detail = '') {
+ if (condition) {
+ passed++;
+ console.log(`PASS ${name}`);
+ } else {
+ failed++;
+ console.log(`FAIL ${name}${detail ? ` -- ${detail}` : ''}`);
+ }
+}
+
+const RATE = 8000;
+const TRACK_SEC = 120;
+const PLAY_SEC = 100;
+const STEP_SEC = 0.1;
+
+class FakeParam {
+ constructor(value = 0) { this.value = value; }
+}
+
+class FakeNode {
+ constructor(ctx, type) {
+ this.ctx = ctx;
+ this.type = type;
+ ctx.nodes.push(this);
+ }
+
+ connect(destination) { return destination; }
+ disconnect() {}
+}
+
+class FakeGain extends FakeNode {
+ constructor(ctx) {
+ super(ctx, 'gain');
+ this.gain = {
+ value: 1,
+ setTargetAtTime: (value) => { this.gain.value = value; },
+ };
+ }
+}
+
+class FakeAnalyser extends FakeNode {
+ constructor(ctx) {
+ super(ctx, 'analyser');
+ this.fftSize = 1024;
+ }
+}
+
+// Records where each source starts and how much of its buffer it plays, which
+// is all the check below needs to know when the feed runs out.
+class FakeSource extends FakeNode {
+ constructor(ctx) {
+ super(ctx, 'source');
+ this.playbackRate = new FakeParam(1);
+ this.buffer = null;
+ }
+
+ start(when, offset = 0) {
+ const played = (this.buffer.duration - offset) / this.playbackRate.value;
+ this.ctx.fedUntil = Math.max(this.ctx.fedUntil, when + played);
+ }
+
+ stop() {}
+}
+
+class FakeContext {
+ constructor({ worklet }) {
+ this.nodes = [];
+ this.currentTime = 0;
+ this.sampleRate = 44100;
+ this.state = 'running';
+ this.fedUntil = 0;
+ this.destination = new FakeNode(this, 'destination');
+ this.audioWorklet = worklet ? { addModule: async () => {} } : null;
+ }
+
+ createGain() { return new FakeGain(this); }
+ createAnalyser() { return new FakeAnalyser(this); }
+ createBufferSource() { return new FakeSource(this); }
+ createBuffer(channels, length, sampleRate) {
+ const data = Array.from({ length: channels }, () => new Float32Array(length));
+ return { duration: length / sampleRate, getChannelData: (channel) => data[channel] };
+ }
+ async resume() {}
+ async close() {}
+ addEventListener() {}
+ removeEventListener() {}
+}
+
+class FakeWorkletNode extends FakeNode {
+ constructor(ctx) {
+ super(ctx, 'worklet');
+ this.parameters = new Map([['tempo', new FakeParam(1)]]);
+ this.port = { postMessage() {} };
+ queueMicrotask(() => this.port.onmessage?.({ data: { type: 'latency', frames: 6541 } }));
+ }
+}
+
+let pendingTick = null;
+globalThis.window = { AudioContext: FakeContext };
+globalThis.AudioWorkletNode = FakeWorkletNode;
+globalThis.requestAnimationFrame = (cb) => { pendingTick = cb; return 1; };
+globalThis.cancelAnimationFrame = () => { pendingTick = null; };
+
+// Mono 16-bit silence. Only the length matters, and a low rate keeps it small.
+function wavBytes(seconds) {
+ const dataBytes = seconds * RATE * 2;
+ const bytes = new ArrayBuffer(44 + dataBytes);
+ const view = new DataView(bytes);
+ const text = (offset, value) => {
+ for (let i = 0; i < value.length; i++) view.setUint8(offset + i, value.charCodeAt(i));
+ };
+ text(0, 'RIFF');
+ view.setUint32(4, bytes.byteLength - 8, true);
+ text(8, 'WAVE');
+ text(12, 'fmt ');
+ view.setUint32(16, 16, true);
+ view.setUint16(20, 1, true);
+ view.setUint16(22, 1, true);
+ view.setUint32(24, RATE, true);
+ view.setUint32(28, RATE * 2, true);
+ view.setUint16(32, 2, true);
+ view.setUint16(34, 16, true);
+ text(36, 'data');
+ view.setUint32(40, dataBytes, true);
+ return new Uint8Array(bytes);
+}
+
+const WAV = wavBytes(TRACK_SEC);
+globalThis.fetch = async (_url, options = {}) => {
+ const match = /bytes=(\d+)-(\d+)/.exec(options.headers?.Range || '');
+ const start = match ? Number(match[1]) : 0;
+ const end = match ? Math.min(Number(match[2]), WAV.length - 1) : WAV.length - 1;
+ const slice = WAV.slice(start, end + 1);
+ return {
+ ok: true,
+ status: match ? 206 : 200,
+ headers: { get: (name) => name === 'Content-Range' ? `bytes ${start}-${end}/${WAV.length}` : null },
+ arrayBuffer: async () => slice.buffer,
+ };
+};
+
+const { createChunkedAudioEngine } = await import('../../static/js/chunkedAudioEngine.js');
+
+// Enough turns of the event loop for a chunk fetch and decode to settle.
+const settle = async () => {
+ for (let i = 0; i < 5; i++) await new Promise((resolve) => setImmediate(resolve));
+};
+
+async function verify(label, { worklet, rate }) {
+ const ctx = new FakeContext({ worklet });
+ const engine = createChunkedAudioEngine([{ name: 'vocals', url: '/vocals.wav' }], { context: ctx });
+ check(`${label}: engine becomes ready`, await engine.ready);
+ check(
+ `${label}: runs on the expected path`,
+ engine.supportsPitchShift() === worklet,
+ );
+ engine.setPlaybackRate(rate);
+ await engine.play();
+
+ let dryAt = null;
+ while (ctx.currentTime < PLAY_SEC) {
+ ctx.currentTime += STEP_SEC;
+ const tick = pendingTick;
+ pendingTick = null;
+ tick?.();
+ await settle();
+ if (dryAt === null && ctx.fedUntil < ctx.currentTime) dryAt = ctx.currentTime;
+ }
+ check(
+ `${label}: sources never run dry over ${PLAY_SEC} s`,
+ dryAt === null,
+ `ran dry at ${dryAt?.toFixed(1)} s`,
+ );
+ engine.destroy();
+}
+
+await verify('SoundTouch at 1x', { worklet: true, rate: 1 });
+await verify('SoundTouch at 0.75x', { worklet: true, rate: 0.75 });
+await verify('tape effect at 0.75x', { worklet: false, rate: 0.75 });
+
+console.log(`\n${passed}/${passed + failed} checks passed`);
+process.exit(failed === 0 ? 0 : 1);
diff --git a/tests/js/source-arming.test.mjs b/tests/js/source-arming.test.mjs
index 42ac1c24..81497239 100644
--- a/tests/js/source-arming.test.mjs
+++ b/tests/js/source-arming.test.mjs
@@ -1,4 +1,4 @@
-// Which track sources the Split stems button may be pointed at (#635).
+// Which track sources the Extract stems button may be pointed at (#635).
//
// The composer is an input that button submits, not a caption for the open
// track. An uploaded file's source is the synthetic "local:my song.mp3", and
diff --git a/tests/js/tempo-attacks.test.mjs b/tests/js/tempo-attacks.test.mjs
new file mode 100644
index 00000000..7ddcfcb2
--- /dev/null
+++ b/tests/js/tempo-attacks.test.mjs
@@ -0,0 +1,148 @@
+// Kicks must not come out doubled at slowed speeds (#728).
+//
+// Below 1x consecutive WSOLA sequences overlap, and an attack in the overlap is
+// played twice. At 0.75x a kick came out as a flam roughly 50 ms long. The
+// tempo stage now carries straight on past an attack instead of replaying it,
+// and borrows the time that costs.
+//
+// Ground truth comes from the signal, not from a detector: a synthetic track of
+// 40 kicks over a sustained chord, so the output must hold exactly 40 attacks.
+// The processor is driven exactly as an AudioWorklet would drive it.
+//
+// Run: node tests/js/tempo-attacks.test.mjs
+
+import { readFileSync } from 'node:fs';
+
+const SR = 44100;
+const BLOCK = 128;
+const TEMPO = 0.75;
+const KICKS = 40;
+const KICK_EVERY = 0.5;
+const INPUT_COUNT = 13;
+const ZERO_INPUT = 6;
+// The processor's own MAX_BORROW_MS, in output time, plus a few milliseconds
+// of measurement slack.
+const MAX_SHIFT = 0.1 / TEMPO + 0.005;
+
+let passed = 0;
+let failed = 0;
+
+function check(name, condition, detail = '') {
+ if (condition) {
+ passed++;
+ console.log(`PASS ${name}`);
+ } else {
+ failed++;
+ console.log(`FAIL ${name}${detail ? ` -- ${detail}` : ''}`);
+ }
+}
+
+const SRC = readFileSync(new URL('../../static/vendor/soundtouch-processor.js', import.meta.url), 'utf8');
+
+function load() {
+ let Cls = null;
+ new Function('sampleRate', 'AudioWorkletProcessor', 'registerProcessor', SRC)(
+ SR,
+ class { constructor() { this.port = { onmessage: null, postMessage() {} }; } },
+ (_name, c) => { Cls = c; },
+ );
+ return Cls;
+}
+
+/** A kick is a 3 kHz click and a 60 Hz thump, over an A minor chord that never stops. */
+function track() {
+ const n = Math.round((KICKS * KICK_EVERY + 0.5) * SR);
+ const x = new Float32Array(n);
+ for (let i = 0; i < n; i++) {
+ const t = i / SR;
+ x[i] = 0.08 * (Math.sin(2 * Math.PI * 220 * t) + Math.sin(2 * Math.PI * 261.63 * t) + Math.sin(2 * Math.PI * 329.63 * t));
+ }
+ for (let k = 0; k < KICKS; k++) {
+ const at = Math.round((0.25 + k * KICK_EVERY) * SR);
+ for (let i = 0; i < 0.15 * SR && at + i < n; i++) {
+ const t = i / SR;
+ const click = t < 0.003 ? 0.5 * Math.sin(2 * Math.PI * 3000 * t) * (1 - t / 0.003) : 0;
+ x[at + i] += click + 0.6 * Math.sin(2 * Math.PI * 60 * t) * Math.exp(-t / 0.04);
+ }
+ }
+ return x;
+}
+
+function stretch(x) {
+ const Processor = load();
+ const p = new Processor();
+ const total = Math.round(x.length / TEMPO) + SR;
+ const out = new Float32Array(Math.ceil(total / BLOCK) * BLOCK);
+ const params = { tempo: new Float32Array([TEMPO]) };
+ for (let pos = 0; pos < out.length; pos += BLOCK) {
+ const block = new Float32Array(BLOCK);
+ if (pos < x.length) block.set(x.subarray(pos, Math.min(pos + BLOCK, x.length)));
+ const inputs = Array.from({ length: INPUT_COUNT }, (_, k) => (k === ZERO_INPUT ? [block, block] : []));
+ const l = new Float32Array(BLOCK);
+ const r = new Float32Array(BLOCK);
+ p.process(inputs, [[l, r]], params);
+ out.set(l, pos);
+ }
+ return out;
+}
+
+/**
+ * Attack times in seconds: peaks of the click band's 1 ms envelope above a
+ * third of the loudest, at least 10 ms apart. The chord is too low to reach
+ * it, so each peak is a click, whether first played or replayed.
+ */
+function attacks(y) {
+ const hop = Math.round(SR * 0.001);
+ const env = [];
+ for (let i = hop; i + hop <= y.length; i += hop) {
+ let e = 0;
+ for (let j = 0; j < hop; j++) {
+ const d = y[i + j] - y[i + j - 1];
+ e += d * d;
+ }
+ env.push(e);
+ }
+ const top = Math.max(...env);
+ const out = [];
+ for (let f = 1; f + 1 < env.length; f++) {
+ if (env[f] < top / 3 || env[f] < env[f - 1] || env[f] < env[f + 1]) continue;
+ const t = (f + 1) * hop / SR;
+ if (out.length && t - out.at(-1) < 0.01) continue;
+ out.push(t);
+ }
+ return out;
+}
+
+const input = track();
+check('the probe sees every kick in the input', attacks(input).length === KICKS, `saw ${attacks(input).length}`);
+
+const found = attacks(stretch(input));
+check(
+ `every kick comes out once at ${TEMPO}x`,
+ found.length === KICKS,
+ `heard ${found.length} attacks for ${KICKS} kicks`,
+);
+
+// Borrowed time is paid back, so each kick lands within the loan of where an
+// exact clock puts it. The first kick fixes the stage's latency.
+const shifts = found.slice(0, KICKS).map((t, k) => t - found[0] - (k * KICK_EVERY) / TEMPO);
+const worst = Math.max(...shifts.map(Math.abs));
+check(
+ 'no kick drifts further than the borrow limit',
+ worst <= MAX_SHIFT,
+ `worst ${(worst * 1000).toFixed(1)} ms`,
+);
+check(
+ 'the last kick is back on the clock',
+ Math.abs(shifts.at(-1)) <= MAX_SHIFT,
+ `${(shifts.at(-1) * 1000).toFixed(1)} ms`,
+);
+
+// Borrowing moves a chain's clock. The pitch stages are aligned sample for
+// sample with the unpitched drums, so only the shared tempo stage may do it.
+const enabled = [...SRC.matchAll(/new Wsola\([^)]*keepAttacks: true/g)].length;
+const tempoStage = /this\._wsola = new Wsola\(sampleRate, \{ keepAttacks: true \}\)/.test(SRC);
+check('only the shared tempo stage keeps attacks', enabled === 1 && tempoStage, `enabled in ${enabled} places`);
+
+console.log(`\n${passed}/${passed + failed} checks passed`);
+process.exit(failed === 0 ? 0 : 1);
diff --git a/tests/keyset.py b/tests/keyset.py
new file mode 100644
index 00000000..9b0736d6
--- /dev/null
+++ b/tests/keyset.py
@@ -0,0 +1,106 @@
+"""A labelled set of synthetic songs for measuring key detection (#726).
+
+Each song is a chord loop over a bass line, rendered to audio with numpy, so
+the right answer is known and nothing is downloaded. The harmony and the bass
+come back separately as well as mixed, which is what lets the full-mix path
+and the stems path be scored on the same material.
+
+The progressions are the ones that make relative keys hard: a minor loop such
+as i-VI-III-VII uses exactly the notes of its relative major. Like real songs,
+each loop starts on its tonic chord and the song ends on it.
+"""
+
+from __future__ import annotations
+
+import zlib
+from dataclasses import dataclass
+
+import numpy as np
+
+SR = 22050
+PITCHES = ("C", "C#", "D", "D#", "E", "F", "F#", "G", "G#", "A", "A#", "B")
+
+# Chords as (semitones above the tonic, quality). "M" major, "m" minor.
+PROGRESSIONS: dict[str, tuple[str, list[tuple[int, str]]]] = {
+ # Major keys
+ "I-V-vi-IV": ("maj", [(0, "M"), (7, "M"), (9, "m"), (5, "M")]),
+ "I-IV-V-I": ("maj", [(0, "M"), (5, "M"), (7, "M"), (0, "M")]),
+ "I-vi-IV-V": ("maj", [(0, "M"), (9, "m"), (5, "M"), (7, "M")]),
+ "I-bVII-IV-I": ("maj", [(0, "M"), (10, "M"), (5, "M"), (0, "M")]),
+ "vi-IV-I-V": ("maj", [(9, "m"), (5, "M"), (0, "M"), (7, "M")]),
+ # Natural minor keys
+ "i-VI-III-VII": ("min", [(0, "m"), (8, "M"), (3, "M"), (10, "M")]),
+ "i-VII-VI-VII": ("min", [(0, "m"), (10, "M"), (8, "M"), (10, "M")]),
+ "i-iv-v-i": ("min", [(0, "m"), (5, "m"), (7, "m"), (0, "m")]),
+ "i-III-VII-iv": ("min", [(0, "m"), (3, "M"), (10, "M"), (5, "m")]),
+ # Harmonic minor: a major V carries the raised seventh
+ "i-iv-V-i": ("hmin", [(0, "m"), (5, "m"), (7, "M"), (0, "m")]),
+ "i-VI-iv-V": ("hmin", [(0, "m"), (8, "M"), (5, "m"), (7, "M")]),
+}
+
+# Every progression in three keys, spread round the circle.
+TONICS = (11, 4, 7) # B, E, G
+
+
+@dataclass
+class Song:
+ name: str
+ tonic: int
+ mode: str # "maj", "min" or "hmin"
+ harmony: np.ndarray
+ bass: np.ndarray
+
+ @property
+ def mix(self) -> np.ndarray:
+ return self.harmony + self.bass
+
+ @property
+ def label(self) -> str:
+ return f"{PITCHES[self.tonic]} {'maj' if self.mode == 'maj' else 'min'}"
+
+ @property
+ def scale(self) -> str:
+ return {"maj": "Major", "min": "Natural Minor", "hmin": "Harmonic Minor"}[self.mode]
+
+
+def _tone(freq: float, n: int, harmonics: int, rng: np.random.Generator) -> np.ndarray:
+ t = np.arange(n) / SR
+ phase = rng.uniform(0, 2 * np.pi)
+ out = np.zeros(n)
+ for h in range(1, harmonics + 1):
+ out += np.sin(2 * np.pi * freq * h * t + phase * h) / h
+ # A short attack and release, so chord changes are not clicks.
+ env = np.minimum(1.0, np.minimum(t / 0.02, (n / SR - t) / 0.05))
+ return out * np.clip(env, 0, 1)
+
+
+def _midi_freq(midi: int) -> float:
+ return 440.0 * 2 ** ((midi - 69) / 12)
+
+
+def render(name: str, tonic: int, bars_per_chord: int = 1, loops: int = 4, bpm: int = 110) -> Song:
+ mode, chords = PROGRESSIONS[name]
+ rng = np.random.default_rng(zlib.crc32(f"{name}/{tonic}".encode()))
+ bar = int(SR * 4 * 60 / bpm) * bars_per_chord
+ harmony: list[np.ndarray] = []
+ bass: list[np.ndarray] = []
+ sequence = chords * loops + [chords[0]] # end on the tonic chord
+ for offset, quality in sequence:
+ root = tonic + offset
+ third = 4 if quality == "M" else 3
+ chord = np.zeros(bar)
+ for interval in (0, third, 7):
+ chord += _tone(_midi_freq(60 + (root + interval) % 12), bar, 6, rng)
+ harmony.append(0.12 * chord)
+ # Root on the beat, fifth on the offbeats: a plain rock bass line.
+ beat = bar // (4 * bars_per_chord)
+ line = np.zeros(bar)
+ for b in range(4 * bars_per_chord):
+ note = root if b % 2 == 0 else root + 7
+ line[b * beat : (b + 1) * beat] = _tone(_midi_freq(36 + note % 12), beat, 4, rng)
+ bass.append(0.25 * line)
+ return Song(name, tonic % 12, mode, np.concatenate(harmony), np.concatenate(bass))
+
+
+def songs() -> list[Song]:
+ return [render(name, tonic) for name in PROGRESSIONS for tonic in TONICS]
diff --git a/tests/test_csp.py b/tests/test_csp.py
index 53833ff5..6a0ecb20 100644
--- a/tests/test_csp.py
+++ b/tests/test_csp.py
@@ -22,25 +22,30 @@ def test_connect_src_permits_data_and_blob():
assert "blob:" in connect
-def test_connect_src_allows_the_artist_and_lyrics_hosts_and_nothing_wider():
- # The artist box and the Lyrics tab (#699) read Wikidata, Wikipedia and
- # LRCLIB straight from the page. Those hosts by name, never a bare https:
- # that would let an injected script send anything anywhere.
+def test_connect_src_allows_the_artist_hosts_and_nothing_wider():
+ # The artist box (#699) reads Wikidata and Wikipedia straight from the
+ # page. Those hosts by name, never a bare https: that would let an
+ # injected script send anything anywhere. LRCLIB is not among them: the
+ # Lyrics tab asks the server to look lyrics up (#719).
sources = _csp_directive("connect-src").split()[1:]
for host in (
"https://www.wikidata.org",
"https://query.wikidata.org",
"https://*.wikipedia.org",
- "https://lrclib.net",
):
assert host in sources
+ assert "https://lrclib.net" not in sources
assert "https:" not in sources
assert "*" not in sources
def test_script_src_stays_locked():
# Lock #171's intent: loosening connect-src must not weaken the XSS defense.
- script = _csp_directive("script-src")
+ script = _csp_directive("script-src").split()[1:]
assert "'self'" in script
- assert "unsafe-inline" not in script
- assert "unsafe-eval" not in script
+ assert "'unsafe-inline'" not in script
+ assert "'unsafe-eval'" not in script
+ # 'wasm-unsafe-eval' compiles WebAssembly and nothing else: JS eval,
+ # new Function and string timers stay blocked. The Signalsmith tempo stage
+ # needs it (#729). Anything beyond it here is a loosening to justify.
+ assert set(script) == {"'self'", "'wasm-unsafe-eval'"}
diff --git a/tests/test_jobs_favorite.py b/tests/test_jobs_favorite.py
new file mode 100644
index 00000000..f388cc50
--- /dev/null
+++ b/tests/test_jobs_favorite.py
@@ -0,0 +1,83 @@
+"""Favourites live on the server, so the phone can set them and filter by them (#734).
+
+They used to live only in the desktop page's catalog store. The phone builds its
+library from GET /api/jobs and had no way to reach that store, so its Favorites
+chip listed every track and there was no heart to press.
+
+`favorite` starts as None, meaning no client has said either way. The desktop
+uses that to hand up favourites it set before the field existed, without
+undoing one taken back out on the phone.
+"""
+
+from __future__ import annotations
+
+import pytest
+from fastapi.testclient import TestClient
+
+from app.core.models import Job
+from app.core.registry import _jobs, register
+from app.main import app
+
+
+@pytest.fixture(autouse=True)
+def _isolate_registry():
+ _jobs.clear()
+ yield
+ _jobs.clear()
+
+
+@pytest.fixture
+def client() -> TestClient:
+ return TestClient(app)
+
+
+def _done(job_id: str) -> Job:
+ job = Job(id=job_id, status="done", title="Song")
+ register(job)
+ return job
+
+
+def test_a_new_job_has_said_nothing_about_favourites(client: TestClient) -> None:
+ _done("aaaaaaaaaaaa")
+ assert client.get("/api/jobs/aaaaaaaaaaaa").json()["favorite"] is None
+
+
+def test_favourite_and_back_out(client: TestClient) -> None:
+ _done("aaaaaaaaaaaa")
+ resp = client.put("/api/jobs/aaaaaaaaaaaa/favorite", json={"favorite": True})
+ assert resp.status_code == 200
+ assert resp.json() == {"job_id": "aaaaaaaaaaaa", "favorite": True}
+ assert client.get("/api/jobs").json()[0]["favorite"] is True
+
+ resp = client.put("/api/jobs/aaaaaaaaaaaa/favorite", json={"favorite": False})
+ assert resp.json()["favorite"] is False
+ # False, not None: taken back out is an answer the desktop must respect.
+ assert client.get("/api/jobs/aaaaaaaaaaaa").json()["favorite"] is False
+
+
+def test_the_flag_survives_a_restart() -> None:
+ job = _done("aaaaaaaaaaaa")
+ job.favorite = True
+ assert Job.from_record(job.to_record()).favorite is True
+
+
+@pytest.mark.parametrize("body", [{}, {"favorite": "false"}, {"favorite": 1}, {"favorite": None}])
+def test_anything_but_a_bool_is_refused(client: TestClient, body: dict) -> None:
+ _done("aaaaaaaaaaaa")
+ resp = client.put("/api/jobs/aaaaaaaaaaaa/favorite", json=body)
+ assert resp.status_code == 422
+ assert client.get("/api/jobs/aaaaaaaaaaaa").json()["favorite"] is None
+
+
+def test_unknown_job_is_404(client: TestClient) -> None:
+ assert client.put("/api/jobs/999999999999/favorite", json={"favorite": True}).status_code == 404
+
+
+@pytest.mark.parametrize(
+ "job_id", ["../../etc/passwd", "..%2F..%2Fetc", "not-a-job-id", "AAAAAAAAAAAA"]
+)
+def test_crafted_ids_are_refused_not_500(client: TestClient, job_id: str) -> None:
+ """Some are collapsed before routing and nothing answers PUT there (405);
+ the rest arrive as a job id and are refused (404). Never a 500."""
+ resp = client.put(f"/api/jobs/{job_id}/favorite", json={"favorite": True})
+ assert resp.status_code in (404, 405)
diff --git a/tests/test_key_detection.py b/tests/test_key_detection.py
new file mode 100644
index 00000000..617f44a1
--- /dev/null
+++ b/tests/test_key_detection.py
@@ -0,0 +1,156 @@
+"""Telling a minor key from its relative major (#726).
+
+A minor loop such as i-VI-III-VII uses exactly the notes of its relative
+major, so a whole-song pitch histogram cannot separate them. The detector used
+to break the tie by how loud each candidate's root was, and in a minor song
+the relative major's root is usually louder: every i-VI-III-VII came out as
+its relative major, at up to 100% confidence. "Plug in Baby", in B minor,
+came out as D major.
+
+These score the detector on tests/keyset.py, synthetic songs whose keys are
+known. On that set the old detector got 27 of 33 keys and 21 of 33 keys with
+their scale; it never reported harmonic minor.
+"""
+
+from __future__ import annotations
+
+import wave
+from pathlib import Path
+
+import numpy as np
+import pytest
+
+from app.core.models import Job
+from app.pipeline import analyze as az
+from tests import keyset
+from tests.ffmpeg_probe import skip_without_ffmpeg
+
+
+def _stems_key(song: keyset.Song) -> tuple[str, str, int]:
+ result = az.detect_key_from_audio(
+ song.harmony.astype(np.float32), song.bass.astype(np.float32), keyset.SR
+ )
+ assert result is not None
+ return result
+
+
+def _mix_key(song: keyset.Song) -> tuple[str, str, int]:
+ import librosa
+
+ harmonic, _ = librosa.effects.hpss(song.mix.astype(np.float32))
+ result = az.detect_key_from_audio(harmonic, None, keyset.SR)
+ assert result is not None
+ return result
+
+
+def test_the_reported_loop_is_minor_from_the_mix():
+ # B minor, i-VI-III-VII: the old detector said D major.
+ song = keyset.render("i-VI-III-VII", 11)
+ label, scale, _ = _mix_key(song)
+ assert (label, scale) == ("B min", "Natural Minor")
+
+
+@pytest.mark.parametrize(
+ "name, tonic",
+ [("i-VI-III-VII", 11), ("i-VII-VI-VII", 7), ("I-V-vi-IV", 4), ("i-iv-v-i", 4)],
+)
+def test_keys_from_stems(name, tonic):
+ song = keyset.render(name, tonic)
+ label, scale, _ = _stems_key(song)
+ assert (label, scale) == (song.label, song.scale)
+
+
+@pytest.mark.parametrize("name", ["i-iv-V-i", "i-VI-iv-V"])
+def test_a_major_five_reads_as_harmonic_minor(name):
+ song = keyset.render(name, 4)
+ label, scale, _ = _stems_key(song)
+ assert (label, scale) == ("E min", "Harmonic Minor")
+
+
+def test_the_whole_labelled_set_from_stems():
+ # 30 of 33 when this was written. The three misses are vi-IV-I-V, which
+ # starts and ends on its minor chord and reads as minor: ambiguous enough
+ # that the set's "major" label is arguable.
+ songs = keyset.songs()
+ right = sum(_stems_key(s)[:2] == (s.label, s.scale) for s in songs)
+ assert right >= 30, f"{right} of {len(songs)}"
+
+
+def test_confidence_does_not_depend_on_level():
+ # It did: the old score multiplied correlation by a raw chroma value, so
+ # the same vector read 100% raw and 21% normalised.
+ vec = [0.9, 0.05, 0.4, 0.05, 0.7, 0.4, 0.05, 0.8, 0.05, 0.5, 0.05, 0.4]
+ edges = [([1.0, 0, 0, 0, 0.8, 0, 0, 0.9, 0, 0, 0, 0], [1.0] + [0.0] * 11)]
+ for with_edges in (None, edges):
+ loud = az._detect_key([v * 5 for v in vec], with_edges)
+ quiet = az._detect_key([v / 5 for v in vec], with_edges)
+ assert loud == quiet
+
+
+def test_edges_decide_between_a_key_and_its_relative():
+ # The same histogram, opened on a C major chord or on an A minor one.
+ diatonic = [1.0, 0.05, 0.8, 0.05, 0.9, 0.8, 0.05, 0.9, 0.05, 0.9, 0.05, 0.7]
+ c_chord = [1.0, 0, 0, 0, 0.9, 0, 0, 0.9, 0, 0, 0, 0]
+ a_chord = [0.9, 0, 0, 0, 0.9, 0, 0, 0, 0, 1.0, 0, 0]
+ c_bass = [1.0] + [0.0] * 11
+ a_bass = [0.0] * 9 + [1.0, 0.0, 0.0]
+ assert az._detect_key(diatonic, [(c_chord, c_bass)])[0] == "C maj"
+ assert az._detect_key(diatonic, [(a_chord, a_bass)])[0] == "A min"
+
+
+# ── refine_key_from_stems ────────────────────────────────────────────
+
+
+def _write_wav(path: Path, samples: np.ndarray, sr: int) -> None:
+ pcm = (np.clip(samples, -1, 1) * 32767).astype(" Job:
+ job = Job(id="a1b2c3d4e5f6")
+ job.key, job.scale, job.key_confidence = key, scale, 90
+ return job
+
+
+def _stems_dir(job: Job) -> Path:
+ # The decoder only reads inside the jobs directory, which the test
+ # fixtures point at a temporary one.
+ d = az.JOBS_DIR / job.id / "stems"
+ d.mkdir(parents=True, exist_ok=True)
+ return d
+
+
+def test_stems_replace_the_mix_estimate():
+ skip_without_ffmpeg()
+ song = keyset.render("i-VI-III-VII", 11)
+ job = _job()
+ stems = _stems_dir(job)
+ _write_wav(stems / "other.wav", song.harmony, keyset.SR)
+ _write_wav(stems / "bass.wav", song.bass, keyset.SR)
+ az.refine_key_from_stems(job, stems)
+ assert (job.key, job.scale) == ("B min", "Natural Minor")
+
+
+def test_no_stems_keeps_the_mix_estimate():
+ job = _job()
+ az.refine_key_from_stems(job, _stems_dir(job))
+ assert (job.key, job.scale, job.key_confidence) == ("D maj", "Major", 90)
+
+
+def test_a_failure_keeps_the_mix_estimate(monkeypatch):
+ skip_without_ffmpeg()
+ song = keyset.render("i-VI-III-VII", 11)
+ job = _job()
+ stems = _stems_dir(job)
+ _write_wav(stems / "other.wav", song.harmony, keyset.SR)
+
+ def boom(*_a, **_k):
+ raise RuntimeError("chroma exploded")
+
+ monkeypatch.setattr(az, "detect_key_from_audio", boom)
+ az.refine_key_from_stems(job, stems)
+ assert (job.key, job.scale, job.key_confidence) == ("D maj", "Major", 90)
diff --git a/tests/test_lyrics_api.py b/tests/test_lyrics_api.py
index 3aff16c2..d45056aa 100644
--- a/tests/test_lyrics_api.py
+++ b/tests/test_lyrics_api.py
@@ -648,3 +648,86 @@ def test_other_versions_of_another_song_are_not_offered(client):
_lyrics_file(job).write_text(json.dumps({**LYRICS, "others": others}), encoding="utf-8")
got = client.get(f"/api/jobs/{job.id}/lyrics").json()
assert [o["lrclib_id"] for o in got["others"]] == [8]
+
+
+# ── POST .../lyrics/lookup: the tab asks the server, not LRCLIB (#719) ──
+
+
+def test_lookup_keeps_lyrics_the_way_the_import_does(client):
+ job = _done_job(audio_tags=TAGS)
+ lrclib = Lrclib(ROWS)
+ with patch.object(ll, "_fetch_json", lrclib):
+ r = client.post(f"/api/jobs/{job.id}/lyrics/lookup", json={})
+ assert r.status_code == 200
+ assert r.json()["synced"] == "[00:01.00]The smile of dawn"
+ assert _lyrics_file(job).is_file()
+ assert job.has_lyrics is True
+ # And GET answers the same from now on, with no second request.
+ assert client.get(f"/api/jobs/{job.id}/lyrics").json()["synced"] == r.json()["synced"]
+
+
+def test_lookup_uses_the_band_the_studio_saved(client):
+ """No tags: only the band chosen in the artist box, which the studio
+ keeps in its own store, says whose song this is."""
+ job = _done_job()
+ lrclib = Lrclib(ROWS)
+ with patch.object(ll, "_fetch_json", lrclib):
+ r = client.post(f"/api/jobs/{job.id}/lyrics/lookup", json={"band": DT})
+ assert r.status_code == 200
+ assert lrclib.asked
+
+
+def test_lookup_with_nothing_to_go_on_asks_nobody(client):
+ job = _done_job()
+ job.title = ""
+ lrclib = Lrclib(ROWS)
+ with patch.object(ll, "_fetch_json", lrclib):
+ r = client.post(f"/api/jobs/{job.id}/lyrics/lookup", json={})
+ assert r.status_code == 404
+ assert r.json()["nothing_known"] is True
+ assert lrclib.asked == []
+
+
+def test_lookup_offers_other_artists_nothing(client):
+ """Another artist's song of the same name is not this track's lyrics:
+ the server's rule, now the only one."""
+ job = _done_job(audio_tags=TAGS)
+ other = [{**ROWS[0], "artistName": "Someone Else"}]
+ with patch.object(ll, "_fetch_json", Lrclib(other)):
+ r = client.post(f"/api/jobs/{job.id}/lyrics/lookup", json={})
+ assert r.status_code == 404
+ assert r.json().get("others", []) == []
+ assert not _lyrics_file(job).is_file()
+
+
+def test_lookup_offline_is_502_so_the_tab_can_retry(client):
+ job = _done_job(audio_tags=TAGS)
+ # conftest's stand-in answers every request as offline.
+ r = client.post(f"/api/jobs/{job.id}/lyrics/lookup", json={})
+ assert r.status_code == 502
+ assert r.json() == {"detail": "lyrics service unreachable"}
+
+
+def test_lookup_answers_kept_lyrics_without_asking(client):
+ job = _done_job(has_lyrics=True, audio_tags=TAGS)
+ _lyrics_file(job).write_text(json.dumps(LYRICS), encoding="utf-8")
+ lrclib = Lrclib(ROWS)
+ with patch.object(ll, "_fetch_json", lrclib):
+ r = client.post(f"/api/jobs/{job.id}/lyrics/lookup", json={})
+ assert r.status_code == 200
+ assert lrclib.asked == []
+
+
+@pytest.mark.parametrize("band", [{"id": "../etc", "name": "x"}, {"id": "Q1", "name": "x" * 301}])
+def test_lookup_refuses_a_malformed_band(client, band):
+ job = _done_job()
+ r = client.post(f"/api/jobs/{job.id}/lyrics/lookup", json={"band": band})
+ assert r.status_code == 422
+
+
+@pytest.mark.parametrize(
+ "job_id", ["../../etc/passwd", "..%2F..%2Fetc", "not-a-job", "bbbbbbbbbbbb"]
+)
+def test_lookup_crafted_or_unknown_ids_are_refused_not_500(client, job_id):
+ r = client.post(f"/api/jobs/{job_id}/lyrics/lookup", json={})
+ assert r.status_code in (404, 405)
diff --git a/tests/test_torch_unloadable.py b/tests/test_torch_unloadable.py
new file mode 100644
index 00000000..f1d088ff
--- /dev/null
+++ b/tests/test_torch_unloadable.py
@@ -0,0 +1,87 @@
+"""A torch that is installed but cannot load must not take the server down (#730).
+
+On Windows, a CUDA DLL left behind by a half-reverted CUDA install makes torch's
+own DLL loader raise OSError (WinError 127) from `import torch` (#723). The
+device probe caught only ImportError, so with the device on "auto" the backend
+died at startup, and with it forced to CPU every /api/settings call was a 500.
+
+These install an import hook that makes `import torch` raise exactly that, so
+they run whether or not a real torch is present.
+"""
+
+from __future__ import annotations
+
+import importlib.abc
+import importlib.machinery
+import sys
+
+import pytest
+from fastapi.testclient import TestClient
+
+from app.core import config
+
+REASON = "[WinError 127] The specified procedure could not be found. Error loading c10_cuda.dll"
+
+
+class _BrokenTorchLoader(importlib.abc.Loader):
+ def create_module(self, spec):
+ return None
+
+ def exec_module(self, module):
+ raise OSError(REASON)
+
+
+class _BrokenTorchFinder(importlib.abc.MetaPathFinder):
+ def find_spec(self, name, path=None, target=None):
+ if name == "torch":
+ return importlib.machinery.ModuleSpec(name, _BrokenTorchLoader())
+ return None
+
+
+@pytest.fixture
+def broken_torch(monkeypatch):
+ for name in [m for m in sys.modules if m == "torch" or m.startswith("torch.")]:
+ monkeypatch.delitem(sys.modules, name)
+ monkeypatch.setattr(sys, "meta_path", [_BrokenTorchFinder(), *sys.meta_path])
+ monkeypatch.setattr(config, "_torch_load_error", None)
+ yield
+
+
+def test_the_probe_falls_back_to_cpu(broken_torch):
+ assert config.available_torch_devices() == ["cpu"]
+ assert config.detect_torch_device() == "cpu"
+
+
+def test_the_probe_says_why(broken_torch):
+ config.available_torch_devices()
+ assert config.torch_load_error() == f"OSError: {REASON}"
+
+
+def test_the_reason_is_logged_once_per_cause(broken_torch, caplog):
+ with caplog.at_level("ERROR", logger="stemdeck.config"):
+ config.available_torch_devices()
+ config.available_torch_devices()
+ assert len([r for r in caplog.records if "could not be loaded" in r.getMessage()]) == 1
+
+
+def test_settings_still_answer_and_carry_the_error(broken_torch):
+ from app.main import app
+
+ with TestClient(app) as c:
+ resp = c.get("/api/settings")
+ assert resp.status_code == 200
+ body = resp.json()
+ assert body["demucs_devices_available"] == ["cpu"]
+ assert body["torch_error"] == f"OSError: {REASON}"
+
+
+def test_a_working_torch_reports_no_error(monkeypatch):
+ # The healthy path: whatever this machine has, a torch that imports (or is
+ # simply absent) leaves no error behind.
+ monkeypatch.setattr(config, "_torch_load_error", "OSError: stale")
+ try:
+ import torch # noqa: F401
+ except ImportError:
+ monkeypatch.setattr(config, "_torch_load_error", None)
+ config.available_torch_devices()
+ assert config.torch_load_error() is None