diff --git a/app/api/events.py b/app/api/events.py
index dedb0b84..24f683f0 100644
--- a/app/api/events.py
+++ b/app/api/events.py
@@ -8,6 +8,7 @@
 from fastapi.responses import StreamingResponse
 
 from app.core.config import JOB_ID_RE
+from app.core.models import FINISHED_STATUSES
 from app.core.registry import get as registry_get
 
 router = APIRouter(tags=["events"])
@@ -108,9 +109,9 @@ async def stream() -> AsyncIterator[str]:
                     yield f"data: {json.dumps(snapshot)}\n\n"
                     last_v = v
                     keepalive_at = 0
-                    if snapshot["status"] in ("done", "error", "cancelled"):
+                    if snapshot["status"] in FINISHED_STATUSES:
                         return
-                elif job.status in ("done", "error", "cancelled"):
+                elif job.status in FINISHED_STATUSES:
                     # Already-terminal with no pending change (e.g. the job was
                     # done before this connection opened) -- close promptly
                     # instead of idling on int-compares until the SSE cap.
diff --git a/app/api/jobs.py b/app/api/jobs.py
index eecca686..af132f5b 100644
--- a/app/api/jobs.py
+++ b/app/api/jobs.py
@@ -35,15 +35,17 @@
     TIMEOUT_WORK_BACKFILL,
     ffprobe_executable,
 )
-from app.core.models import Job, JobCancelled, _set
+from app.core.models import FINISHED_STATUSES, Job, JobCancelled, _set, settle_cancelled
 from app.core.registry import all_jobs as registry_all_jobs
 from app.core.registry import get as registry_get
 from app.core.registry import get_proc as registry_get_proc
+from app.core.registry import is_upload
 from app.core.registry import mark_deleted as registry_mark_deleted
 from app.core.registry import pending_count as registry_pending_count
 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 requeue_if_capacity as registry_requeue_if_capacity
 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 (
@@ -56,7 +58,7 @@
 from app.pipeline import discogs, jobqueue
 from app.pipeline.artist_lookup import tagged_artist_name
 from app.pipeline.audio_tags import probe_tags
-from app.pipeline.collect import merge_stem_peaks, presence_for_split
+from app.pipeline.collect import merge_stem_peaks, presence_for_split, remove_job_dir
 from app.pipeline.download import InvalidYouTubeURL, fetch_audio_tags, validate_youtube_url
 from app.pipeline.errors import classify_failure
 from app.pipeline.identify import can_identify_title, identify_and_find_band, release_source
@@ -168,23 +170,9 @@ def _rmtree_job(job_id: str) -> bool:
     The outcome used to be swallowed, so delete_job dropped the registry entry
     whether or not anything was actually deleted -- and restore() then adopted
     the surviving directory on the next start, which is how deleted songs came
-    back (#521).
-
-    Retried once: on macOS the common failure is Finder or Spotlight creating
-    a .DS_Store between rmtree's scan and its final rmdir, which leaves
-    "Directory not empty" on a directory that is about to be empty again."""
-    job_dir = JOBS_DIR / job_id
-    for attempt in (1, 2):
-        if not job_dir.is_dir():
-            return True
-        try:
-            shutil.rmtree(job_dir)
-            return True
-        except Exception:
-            logger.warning(
-                "failed to remove job dir %s (attempt %d)", job_dir, attempt, exc_info=True
-            )
-    return not job_dir.is_dir()
+    back (#521). The retry lives in remove_job_dir, shared with the runner's
+    cancel path (#749)."""
+    return remove_job_dir(JOBS_DIR / job_id)
 
 
 def _job_files_missing(job: Job) -> bool:
@@ -403,12 +391,24 @@ def list_jobs(trashed: Literal["exclude", "include", "only"] = "exclude") -> lis
 
 @router.post("/{job_id}/trash")
 def trash_job(job_id: str) -> dict:
-    """Put a job in the Trash. Reversible, and nothing on disk is touched."""
+    """Put a job in the Trash. Reversible, and nothing on disk is touched:
+    only emptying the Trash (DELETE) removes files.
+
+    A job still waiting or running is stopped as well (#748). Trashing used to
+    leave it going, hidden: the queue kept working on a song the user had
+    thrown away, and a stuck one held the queue up with no way to clear it. It
+    settles as "stopped", its files kept, so Restore brings it back and Extract
+    can run it again. Done here rather than in each client so the phone and the
+    desktop behave alike.
+    """
     if not JOB_ID_RE.match(job_id):
         raise HTTPException(status_code=404, detail="job not found")
     job = registry_set_trashed(job_id, True)
     if job is None:
         raise HTTPException(status_code=404, detail="job not found")
+    if job.status not in FINISHED_STATUSES:
+        job.stop_requested = True
+        _cancel_pipeline(job)
     registry_persist(JOBS_DIR)
     return {"job_id": job.id, "trashed_at": job.trashed_at}
 
@@ -425,6 +425,35 @@ def restore_job(job_id: str) -> dict:
     return {"job_id": job.id, "trashed_at": job.trashed_at}
 
 
+@router.post("/{job_id}/extract")
+def extract_stopped_job(job_id: str) -> dict:
+    """Run a stopped job again from the start, from the source it kept (#748).
+
+    The only way a job stopped by the Trash goes back in the queue. Restore
+    does not do it: taking a song out of the Trash is not a request to spend
+    minutes of GPU on it. It has to be out of the Trash first, so a song the
+    user threw away is never extracted by a stray request.
+    """
+    if not JOB_ID_RE.match(job_id):
+        raise HTTPException(status_code=404, detail="job not found")
+    job = registry_get(job_id)
+    if job is None:
+        raise HTTPException(status_code=404, detail="job not found")
+    if job.status != "stopped":
+        raise HTTPException(status_code=409, detail="only a stopped job can be extracted again")
+    if job.trashed_at is not None:
+        raise HTTPException(status_code=409, detail="restore it from the Trash first")
+    limit = MAX_PENDING_UPLOAD_JOBS if is_upload(job) else MAX_PENDING_URL_JOBS
+    if not registry_requeue_if_capacity(job, JOBS_DIR / job_id, limit):
+        raise HTTPException(
+            status_code=503,
+            detail=_UPLOAD_QUEUE_FULL_DETAIL if is_upload(job) else _URL_QUEUE_FULL_DETAIL,
+        )
+    registry_persist(JOBS_DIR)
+    jobqueue.enqueue(job_id)
+    return job.to_state()
+
+
 class FavoriteBody(BaseModel):
     """Strict, so a string such as "false" is refused rather than read as true."""
 
@@ -459,7 +488,7 @@ def cancel_job(job_id: str) -> dict:
     job = registry_get(job_id)
     if job is None:
         raise HTTPException(status_code=404, detail="job not found")
-    if job.status in ("done", "error", "cancelled"):
+    if job.status in FINISHED_STATUSES:
         # A vocal split only ever runs on a done job, so this early return made
         # it uncancellable by construction: the flag was never even set, while
         # the split held _pipeline_lock and stalled the whole import queue for
@@ -478,6 +507,19 @@ def cancel_job(job_id: str) -> dict:
             if proc is not None and proc.poll() is None:
                 proc.terminate()
         return job.to_state()
+    _cancel_pipeline(job)
+    return job.to_state()
+
+
+def _cancel_pipeline(job: Job) -> None:
+    """Stop a job that is waiting or running. Shared by cancel and trash (#748).
+
+    The caller has checked the job is not finished. A running job is only
+    asked to stop here: the pipeline sees the flag, or its process dies, and
+    the runner then settles it: cancelled with its directory removed, or stopped
+    with its files kept when the stop came from the Trash.
+    """
+    job_id = job.id
     job.cancel_requested = True
 
     # Still waiting: the worker will never pick it up, so finalise it here.
@@ -485,10 +527,10 @@ def cancel_job(job_id: str) -> dict:
     # occupying a capacity slot until then, and a queued upload held its source
     # file (up to 400 MB) for the whole wait.
     if jobqueue.discard(job_id):
-        _set(job, status="cancelled", stage="Cancelled")
-        jobqueue.cleanup_job_dir(job_id)
+        if settle_cancelled(job):
+            jobqueue.cleanup_job_dir(job_id)
         registry_persist(JOBS_DIR)
-        return job.to_state()
+        return
 
     # Only the running job owns the shared demucs worker. Terminating on any
     # other id would kill someone else's separation if a stale set_proc entry
@@ -497,7 +539,6 @@ def cancel_job(job_id: str) -> dict:
         proc = registry_get_proc(job_id)
         if proc is not None and proc.poll() is None:
             proc.terminate()
-    return job.to_state()
 
 
 def _write_vocal_split_error(stems_dir: Path, cause: str, tail: list[str]) -> None:
@@ -1802,7 +1843,7 @@ def delete_job(job_id: str) -> dict[str, str]:
     job = registry_get(job_id)
     if job is None:
         raise HTTPException(status_code=404, detail="job not found")
-    if job.status not in ("done", "error", "cancelled"):
+    if job.status not in FINISHED_STATUSES:
         raise HTTPException(status_code=409, detail="job is still running")
     # A timing of its lyrics in flight stops rather than write into a
     # directory being removed (it also checks the job is still registered).
diff --git a/app/core/models.py b/app/core/models.py
index e51c84d2..4e0a1b85 100644
--- a/app/core/models.py
+++ b/app/core/models.py
@@ -15,9 +15,22 @@ class JobCancelled(Exception):
 
 
 JobStatus = Literal[
-    "queued", "downloading", "analyzing", "separating", "processing", "done", "error", "cancelled"
+    "queued",
+    "downloading",
+    "analyzing",
+    "separating",
+    "processing",
+    "done",
+    "error",
+    "cancelled",
+    "stopped",
 ]
 
+# Statuses no pipeline will move on from. "stopped" is a job halted because the
+# user put it in the Trash (#748): unlike "cancelled", its files stay on disk,
+# because only emptying the Trash deletes anything.
+FINISHED_STATUSES = frozenset(("done", "error", "cancelled", "stopped"))
+
 # A Wikidata item id. Anything else is not a band this app found.
 _WIKIDATA_ID_RE = re.compile(r"^Q\d{1,12}$")
 # A band's name, as kept on the job. Longer than this is not a name.
@@ -195,6 +208,20 @@ def _set(job: Job, **fields: object) -> None:
     job.version += 1
 
 
+def settle_cancelled(job: Job) -> bool:
+    """Mark a job whose cancel took effect. Returns whether its files go too.
+
+    A plain cancel ends "cancelled" and its directory is removed. A stop that
+    came from the Trash ends "stopped" with the directory kept (#748): trashing
+    is reversible, and only emptying the Trash deletes files, the rule the
+    finished tracks in the Trash have always followed."""
+    if job.stop_requested:
+        _set(job, status="stopped", stage="Stopped")
+        return False
+    _set(job, status="cancelled", stage="Cancelled")
+    return True
+
+
 @dataclass
 class Job:
     id: str
@@ -319,6 +346,10 @@ class Job:
     # 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
+    # Set alongside cancel_requested when the stop comes from the Trash (#748).
+    # The job then settles as "stopped" with its files kept, not "cancelled"
+    # with its directory removed. Internal, like cancel_requested.
+    stop_requested: bool = False
     # Bumped by _set() on every field write (#289). Internal dirty-flag /
     # tear-detection state for the SSE stream -- not surfaced via to_state()
     # or persisted, same as cancel_requested.
@@ -412,9 +443,12 @@ def from_record(cls, data: dict[str, Any]) -> Job:
         job.work = clean_work(job.work)
         job.audio_tags = clean_audio_tags(job.audio_tags)
         job.cancel_requested = False
+        job.stop_requested = False
         return job
 
 
 _JOB_FIELDS = frozenset(
-    f.name for f in dataclasses.fields(Job) if f.name not in ("cancel_requested", "version")
+    f.name
+    for f in dataclasses.fields(Job)
+    if f.name not in ("cancel_requested", "stop_requested", "version")
 )
diff --git a/app/core/registry.py b/app/core/registry.py
index 9b16793f..69cffe21 100644
--- a/app/core/registry.py
+++ b/app/core/registry.py
@@ -29,7 +29,10 @@
 # handed back to the queue -- see restore(). _TERMINAL stays narrow because
 # restore() and _recover_done_job() both mean "finished successfully" by it.
 _RESUMABLE = {"queued", "processing", "downloading", "analyzing", "separating"}
-_PERSISTED = _TERMINAL | _RESUMABLE
+# Halted from the Trash with its files kept (#748). Persisted so a restart
+# keeps it in the Trash, and never resumed: only Extract queues it again.
+_STOPPED = {"stopped"}
+_PERSISTED = _TERMINAL | _RESUMABLE | _STOPPED
 
 # One resume only. A job that reliably kills the process (a demucs OOM taking
 # the backend down with it) would otherwise be re-queued on every start,
@@ -65,6 +68,23 @@ def pending_count(*, uploads: bool) -> int:
         return sum(1 for j in _jobs.values() if j.status == "queued" and is_upload(j) == uploads)
 
 
+def requeue_if_capacity(job: Job, job_dir: Path, max_pending: int) -> bool:
+    """Reset a stopped job and count it as waiting, if its kind has room.
+
+    The same per-kind limit as a new import, checked and applied under one lock
+    so two Extract presses cannot both squeeze into the last slot (#748)."""
+    uploads = is_upload(job)
+    with _lock:
+        pending = sum(1 for j in _jobs.values() if j.status == "queued" and is_upload(j) == uploads)
+        if pending >= max_pending:
+            return False
+        # Claims the slot. The file work in reset_for_rerun stays outside the
+        # lock; the job is not in the queue until the caller enqueues it.
+        job.status = "queued"
+    reset_for_rerun(job, job_dir)
+    return True
+
+
 def register_if_capacity(job: Job, max_pending: int) -> bool:
     """Atomically check pending count and register if under capacity.
     Returns True if registered, False if the queue is full.
@@ -218,7 +238,9 @@ def restore(jobs_dir: Path) -> None:
                 job = Job.from_record(record)
                 if not JOB_ID_RE.match(job.id):
                     continue
-                if job.status in _TERMINAL and job.title:
+                # A stopped job may have no title yet: one trashed before its
+                # download finished still has files and a place in the Trash.
+                if (job.status in _TERMINAL and job.title) or job.status in _STOPPED:
                     to_add[job.id] = job
                 elif job.status in _RESUMABLE:
                     recovered = _resume_or_recover(job, jobs_dir / job.id)
@@ -285,11 +307,25 @@ def _resume_or_recover(job: Job, job_dir: Path) -> Job | None:
     library entry. Otherwise the job goes back in the queue from the top, after
     the partial demucs output is cleared so collect() cannot mistake it for
     results. A job that has already burned its resume is failed loudly rather
-    than retried forever."""
+    than retried forever.
+
+    A job the user trashed before the restart is not resumed (#748). It came
+    back as a Paused row in the queue, offered to Start a song that was in the
+    Trash. It is stopped instead, the same end a trash before the restart now
+    has, and its files stay until the Trash is emptied."""
     recovered = _recover_done_job(job_dir)
     if recovered is not None:
+        # Finished after all: keep it where the user put it, or a song they
+        # binned reappears in the library.
+        recovered.trashed_at = job.trashed_at
         return recovered
 
+    if job.trashed_at is not None:
+        reset_for_rerun(job, job_dir)
+        job.status = "stopped"
+        job.stage_message = "Stopped"
+        return job
+
     job.resume_attempts += 1
     if job.resume_attempts > _MAX_RESUME_ATTEMPTS:
         job.status = "error"
@@ -297,14 +333,26 @@ def _resume_or_recover(job: Job, job_dir: Path) -> Job | None:
         job.error = "Interrupted by a restart twice. Import it again to retry."
         return job
 
+    reset_for_rerun(job, job_dir)
+    return job
+
+
+def reset_for_rerun(job: Job, job_dir: Path) -> None:
+    """Put a job back to the start of the pipeline, its source kept.
+
+    The partial demucs output is cleared so collect() cannot mistake it for
+    results. Shared by a resume after a restart and by extracting a stopped
+    job again (#748). Bumps version, so a stream watching the job sees it."""
     shutil.rmtree(job_dir / DEMUCS_MODEL, ignore_errors=True)
     job.status = "queued"
     job.stage_message = "Queued"
     job.progress = 0.0
     job.cancel_requested = False
+    job.stop_requested = False
+    job.error = None
     job.stems = []
     job.mix_url = None
-    return job
+    job.version += 1
 
 
 def take_pending_resume() -> list[str]:
diff --git a/app/pipeline/analyze.py b/app/pipeline/analyze.py
index 2acbb3f1..03a81820 100644
--- a/app/pipeline/analyze.py
+++ b/app/pipeline/analyze.py
@@ -5,7 +5,8 @@
 from pathlib import Path
 
 from app.core.config import JOBS_DIR, TIMEOUT_ANALYZE, ffmpeg_executable
-from app.core.models import Job, _set
+from app.core.models import Job, JobCancelled, _set
+from app.pipeline.cancel import check_cancel, run_registered
 
 logger = logging.getLogger("stemdeck.analyze")
 
@@ -258,13 +259,18 @@ def _load_audio_ffmpeg(
     sr: int = 22050,
     duration: float | None = 180.0,
     timeout: int = TIMEOUT_ANALYZE,
+    job: Job | None = None,
 ) -> tuple[object, int] | None:
     """Decode `source` to a mono float32 numpy array at `sr` via ffmpeg.
     Bypasses librosa's deprecated audioread fallback (which fires a
     FutureWarning on .webm/.m4a/.opus inputs because soundfile can't
     read those directly). `duration=None` decodes the whole file (used by
     the beat-grid stage, which must cover the full track). Returns
-    (samples, sr) or None on failure."""
+    (samples, sr) or None on failure.
+
+    With `job`, ffmpeg is registered against it so a cancel can terminate the
+    decode rather than wait it out (#748). A terminated decode reads as a
+    failure here; the caller's own cancel check is what turns it into one."""
     import numpy as np
 
     # Defence in depth: even though `source` is constructed by the server
@@ -302,7 +308,10 @@ def _load_audio_ffmpeg(
         cmd += ["-t", str(duration)]  # cap input duration
     cmd.append("-")  # write to stdout
     try:
-        proc = subprocess.run(cmd, capture_output=True, check=True, timeout=timeout)
+        if job is not None:
+            result = run_registered(job, cmd, timeout, capture_stdout=True)
+        else:
+            result = subprocess.run(cmd, capture_output=True, timeout=timeout)
     # OSError, not just FileNotFoundError. A missing binary is only one way
     # spawning fails: a portable install whose ffmpeg lost its executable bit
     # raises PermissionError, which is an OSError but not a FileNotFoundError,
@@ -312,7 +321,10 @@ def _load_audio_ffmpeg(
     except (subprocess.SubprocessError, OSError) as e:
         logger.warning("ffmpeg decode failed for %s: %s", source, e)
         return None
-    y = np.frombuffer(proc.stdout, dtype=np.float32)
+    if result.returncode != 0:
+        logger.warning("ffmpeg decode failed for %s: exit %s", source, result.returncode)
+        return None
+    y = np.frombuffer(result.stdout, dtype=np.float32)
     if y.size == 0:
         return None
     return y, sr
@@ -320,7 +332,11 @@ def _load_audio_ffmpeg(
 
 def analyze(job: Job, source: Path) -> tuple[int | None, str | None]:
     """Best-effort BPM and key detection. On failure, returns (None, None)
-    and leaves job fields untouched -- the chips stay as placeholders."""
+    and leaves job fields untouched -- the chips stay as placeholders.
+
+    A cancel is the one thing that is not swallowed: it raises JobCancelled.
+    The librosa steps cannot be interrupted, so the flag is checked between
+    them, and the decode is registered so cancel can stop it outright (#748)."""
     logger.info("analyze: entering for job %s, source=%s", job.id, source)
     _set(job, status="analyzing", progress=0.0, stage="Analyzing audio...")
     try:
@@ -333,7 +349,8 @@ def analyze(job: Job, source: Path) -> tuple[int | None, str | None]:
         # Analyse the first 180 s. Decode via ffmpeg directly into numpy
         # to avoid librosa's deprecated audioread fallback for
         # .webm/.m4a/.opus inputs.
-        loaded = _load_audio_ffmpeg(source, sr=22050, duration=180.0)
+        loaded = _load_audio_ffmpeg(source, sr=22050, duration=180.0, job=job)
+        check_cancel(job)
         if loaded is None:
             return None, None
         y, sr = loaded
@@ -343,8 +360,10 @@ def analyze(job: Job, source: Path) -> tuple[int | None, str | None]:
         # cleaner pitch profile on the harmonic component (no cymbal
         # smear, no kick fundamentals leaking in).
         y_harmonic, y_percussive = librosa.effects.hpss(y)
+        check_cancel(job)
 
         tempo_arr, beat_frames = librosa.beat.beat_track(y=y_percussive, sr=sr)
+        check_cancel(job)
         try:
             tempo = float(tempo_arr[0])  # type: ignore[index]
         except (TypeError, IndexError):
@@ -359,6 +378,7 @@ def analyze(job: Job, source: Path) -> tuple[int | None, str | None]:
         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)
+        check_cancel(job)
 
         # LUFS / peak. Computed on the same 22 kHz mono buffer; this
         # loses a few dB of accuracy vs full-sample-rate stereo, but
@@ -396,6 +416,8 @@ def analyze(job: Job, source: Path) -> tuple[int | None, str | None]:
             stage="Analysis complete",
         )
         return bpm, key
+    except JobCancelled:
+        raise
     except Exception:
         # Full traceback goes to the log; the UI stage line stays generic --
         # raw exception reprs (paths, library internals) must not reach it.
@@ -490,7 +512,7 @@ def refine_key_from_stems(job: Job, stems_dir: Path) -> None:
             path = stems_dir / f"{name}.wav"
             if not path.is_file():
                 continue
-            loaded = _load_audio_ffmpeg(path, sr=sr, duration=_STEM_KEY_MAX_SECONDS)
+            loaded = _load_audio_ffmpeg(path, sr=sr, duration=_STEM_KEY_MAX_SECONDS, job=job)
             if loaded is None:
                 continue
             y = loaded[0] * weight
@@ -503,7 +525,7 @@ def refine_key_from_stems(job: Job, stems_dir: Path) -> None:
         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)
+            loaded = _load_audio_ffmpeg(bass_path, sr=sr, duration=_STEM_KEY_MAX_SECONDS, job=job)
             if loaded is not None:
                 bass = loaded[0]
                 harmony, bass = _pad_pair(harmony, bass)
diff --git a/app/pipeline/cancel.py b/app/pipeline/cancel.py
new file mode 100644
index 00000000..984ab899
--- /dev/null
+++ b/app/pipeline/cancel.py
@@ -0,0 +1,53 @@
+"""What a pipeline stage needs so a cancel can actually stop it.
+
+Lives apart from runner.py so analyze.py can use it too: runner imports
+analyze, so analyze reaching back into runner would be a circular import. The
+analyze stage had no cancel path at all, and on a long track it runs for over
+a minute (85 s in one report), so a song trashed or cancelled there kept
+"Analyzing" until it finished (#748).
+"""
+
+from __future__ import annotations
+
+import subprocess
+
+from app.core.models import Job, JobCancelled
+from app.core.registry import set_proc
+
+
+def check_cancel(job: Job) -> None:
+    if job.cancel_requested:
+        raise JobCancelled()
+
+
+def run_registered(
+    job: Job, cmd: list[str], timeout: int, *, capture_stdout: bool = False
+) -> subprocess.CompletedProcess[bytes]:
+    """Run a subprocess with it registered, so cancel can reach it.
+
+    subprocess.run() cannot be interrupted: POST /cancel sets the flag, but
+    nothing looks at it until the call returns, so a cancel during a large
+    upload's transcode was a no-op for up to TIMEOUT_FFMPEG per call -- twice
+    over on the .mp4 path, which runs both this and the video extract (#519).
+    The analyze decode had the same hole (#748).
+
+    Mirrors collect._run_ffmpeg, which registers for exactly this reason. A
+    terminated process comes back as a non-zero returncode, never an
+    exception; a timeout kills it and raises subprocess.TimeoutExpired.
+    """
+    proc = subprocess.Popen(
+        cmd,
+        stdout=subprocess.PIPE if capture_stdout else subprocess.DEVNULL,
+        stderr=subprocess.PIPE,
+    )
+    set_proc(job.id, proc)
+    try:
+        try:
+            stdout, stderr = proc.communicate(timeout=timeout)
+        except subprocess.TimeoutExpired:
+            proc.kill()
+            proc.communicate()
+            raise
+        return subprocess.CompletedProcess(cmd, proc.returncode, stdout or b"", stderr or b"")
+    finally:
+        set_proc(job.id, None)
diff --git a/app/pipeline/collect.py b/app/pipeline/collect.py
index 0b6fd1f1..f995ac3c 100644
--- a/app/pipeline/collect.py
+++ b/app/pipeline/collect.py
@@ -15,7 +15,7 @@
     TIMEOUT_FFMPEG,
     ffmpeg_executable,
 )
-from app.core.models import Job
+from app.core.models import FINISHED_STATUSES, Job
 from app.core.registry import all_jobs as registry_all
 from app.core.registry import persist as registry_persist
 from app.core.registry import remove as registry_remove
@@ -68,7 +68,29 @@ def _run_ffmpeg(job: Job, cmd: list[str]) -> bool:
         set_proc(job.id, None)
 
 
-_TERMINAL = frozenset(("done", "error", "cancelled"))
+def remove_job_dir(job_dir: Path) -> bool:
+    """Remove a job's directory. False means files are still on disk.
+
+    Retried once: on macOS the common failure is Finder or Spotlight creating
+    a .DS_Store between rmtree's scan and its final rmdir, which leaves
+    "Directory not empty" on a directory that is about to be empty again. On
+    Windows it is a handle a process that just exited has not quite let go of,
+    which is what the runner's cancel path meets right after terminating
+    ffmpeg or the demucs worker (#749). Shared by delete_job and that path."""
+    for attempt in (1, 2):
+        if not job_dir.is_dir():
+            return True
+        try:
+            shutil.rmtree(job_dir)
+            return True
+        except Exception:
+            logger.warning(
+                "failed to remove job dir %s (attempt %d)", job_dir, attempt, exc_info=True
+            )
+    return not job_dir.is_dir()
+
+
+_TERMINAL = FINISHED_STATUSES
 
 
 def collect(job: Job, stems_root: Path, job_dir: Path) -> list[str]:
diff --git a/app/pipeline/jobqueue.py b/app/pipeline/jobqueue.py
index ae872b23..9e61dd91 100644
--- a/app/pipeline/jobqueue.py
+++ b/app/pipeline/jobqueue.py
@@ -26,7 +26,7 @@
 from pathlib import Path
 
 from app.core.config import JOBS_DIR
-from app.core.models import Job, _set
+from app.core.models import FINISHED_STATUSES, Job, _set, settle_cancelled
 from app.core.registry import get as registry_get
 from app.core.registry import persist as registry_persist
 
@@ -208,10 +208,10 @@ def _finalise_dropped_job(job: Job) -> None:
     running slot, so a cancel arriving there sets cancel_requested and returns.
     The worker owns the job by then and is the only thing that can close it
     out (#520)."""
-    if not job.cancel_requested or job.status in ("done", "error", "cancelled"):
+    if not job.cancel_requested or job.status in FINISHED_STATUSES:
         return
-    _set(job, status="cancelled", stage="Cancelled")
-    cleanup_job_dir(job.id)
+    if settle_cancelled(job):
+        cleanup_job_dir(job.id)
     registry_persist(JOBS_DIR)
 
 
@@ -234,7 +234,7 @@ async def _worker_loop() -> None:
         job = registry_get(job_id)
         if job is None:
             continue
-        if job.cancel_requested or job.status in ("done", "error", "cancelled"):
+        if job.cancel_requested or job.status in FINISHED_STATUSES:
             # Cancelled or finished while it waited.
             #
             # Finalising here is not optional. Between _pop_next() above and
diff --git a/app/pipeline/runner.py b/app/pipeline/runner.py
index ab484902..4f06fcec 100644
--- a/app/pipeline/runner.py
+++ b/app/pipeline/runner.py
@@ -17,18 +17,21 @@
     LYRICS_LOOKUP_GRACE_SEC,
     TIMEOUT_FFMPEG,
 )
-from app.core.models import Job, JobCancelled, _set
+from app.core.models import Job, JobCancelled, _set, settle_cancelled
 from app.core.redact import redact
-from app.core.registry import is_upload, set_proc
+from app.core.registry import is_upload
 from app.core.registry import persist as persist_registry
 from app.pipeline.analyze import analyze, refine_key_from_stems
 from app.pipeline.beatgrid import compute_beat_grid
+from app.pipeline.cancel import check_cancel as _check_cancel
+from app.pipeline.cancel import run_registered
 from app.pipeline.collect import (
     cleanup_source,
     collect,
     compute_stem_peaks,
     make_original_track,
     make_selected_mix,
+    remove_job_dir,
 )
 from app.pipeline.download import download
 from app.pipeline.errors import classify_failure
@@ -55,35 +58,6 @@ def _rmtree(path: Path) -> None:
 _pipeline_lock = asyncio.Semaphore(1)
 
 
-def _check_cancel(job: Job) -> None:
-    if job.cancel_requested:
-        raise JobCancelled()
-
-
-def _run_registered_ffmpeg(job: Job, cmd: list[str], timeout: int) -> tuple[int, bytes]:
-    """Run ffmpeg with the process registered, so cancel can reach it.
-
-    subprocess.run() cannot be interrupted: POST /cancel sets the flag, but
-    nothing looks at it until the call returns, so a cancel during a large
-    upload's transcode was a no-op for up to TIMEOUT_FFMPEG per call -- twice
-    over on the .mp4 path, which runs both this and the video extract (#519).
-
-    Mirrors collect._run_ffmpeg, which registers for exactly this reason.
-    """
-    proc = subprocess.Popen(cmd, stdout=subprocess.DEVNULL, stderr=subprocess.PIPE)
-    set_proc(job.id, proc)
-    try:
-        try:
-            _, stderr = proc.communicate(timeout=timeout)
-        except subprocess.TimeoutExpired:
-            proc.kill()
-            proc.communicate()
-            raise
-        return proc.returncode, stderr or b""
-    finally:
-        set_proc(job.id, None)
-
-
 def _extract_video_track(job: Job, source: Path, job_dir: Path) -> None:
     """For an .mp4 upload, preserve a silent video-only track at
     video.mp4 so the studio can later mux it with a custom stem mix
@@ -111,7 +85,7 @@ def _extract_video_track(job: Job, source: Path, job_dir: Path) -> None:
         str(dest),
     ]
     try:
-        returncode, _ = _run_registered_ffmpeg(job, cmd, TIMEOUT_FFMPEG)
+        returncode = run_registered(job, cmd, TIMEOUT_FFMPEG).returncode
     except (OSError, subprocess.SubprocessError) as e:
         # ffmpeg missing or timed out. Distinct from an .mp4 that simply has no
         # video stream, and the only one of the two worth surfacing (#436).
@@ -162,10 +136,10 @@ def _prepare_local_source(job: Job, source: Path, job_dir: Path) -> Path:
         "-y",
         str(dest),
     ]
-    returncode, stderr = _run_registered_ffmpeg(job, cmd, TIMEOUT_FFMPEG)
-    if returncode != 0:
+    result = run_registered(job, cmd, TIMEOUT_FFMPEG)
+    if result.returncode != 0:
         raise RuntimeError(
-            "ffmpeg transcode failed: " + stderr.decode("utf-8", errors="replace").strip()
+            "ffmpeg transcode failed: " + result.stderr.decode("utf-8", errors="replace").strip()
         )
     source.unlink(missing_ok=True)
     return dest
@@ -495,11 +469,23 @@ async def _run_async(
             " (wrapped)" if not isinstance(e, JobCancelled) else "",
             job.id,
         )
-        _set(job, status="cancelled", stage="Cancelled")
+        remove_files = settle_cancelled(job)
         persist_registry(jobs_dir)
         release_source(job.id)
-        _rmtree(job_dir)
+        # A job stopped from the Trash keeps its files until the Trash is
+        # emptied (#748). A plain cancel's folder is retried like delete_job's
+        # removal: right after the cancel terminated ffmpeg or the demucs
+        # worker, Windows can still hold one of its files, and a single attempt
+        # left the folder behind for good.
+        if remove_files and not remove_job_dir(job_dir):
+            logger.warning("[%s] cancelled job's folder could not be removed", job.id)
         return
+    # A cancel or a trash that arrived after the last stage checked for it lost
+    # the race, and the job finished anyway. Left set, the flags would make
+    # every later vocal split, section run or lyric timing on this done job
+    # cancel itself at once, until the next restart (#748).
+    job.cancel_requested = False
+    job.stop_requested = False
     _set(job, status="done", progress=1.0, stage="Done")
     _write_metadata(job, job_dir)
     persist_registry(jobs_dir)
diff --git a/desktop/src-tauri/src/main.rs b/desktop/src-tauri/src/main.rs
index 442e0c0f..735bdaa2 100644
--- a/desktop/src-tauri/src/main.rs
+++ b/desktop/src-tauri/src/main.rs
@@ -361,6 +361,32 @@ fn main() {
         .plugin(tauri_plugin_dialog::init())
         .plugin(tauri_plugin_store::Builder::default().build())
         .setup(|app| {
+            // A portable folder the user cannot write to (Program Files, say)
+            // cannot work at all: setup, the CUDA swap and the updater all
+            // write inside it. Say so and stop, before the window opens and
+            // before anything touches the install (#746).
+            #[cfg(any(windows, target_os = "linux"))]
+            if let Ok(root) = app_root() {
+                let outcome =
+                    portable_root_check(is_portable_package(&root), || app_root_is_writable(&root));
+                if outcome == PortableRootCheck::NotWritable {
+                    use tauri_plugin_dialog::DialogExt;
+                    eprintln!(
+                        "[stemdeck] portable folder is not writable: {}",
+                        root.display()
+                    );
+                    // Non-blocking show: the setup hook runs on the main
+                    // thread, and the callback ends the process once the
+                    // user has read the message.
+                    app.dialog()
+                        .message(not_writable_message(&root))
+                        .title("StemDeck cannot start here")
+                        .kind(tauri_plugin_dialog::MessageDialogKind::Error)
+                        .show(|_| std::process::exit(0));
+                    return Ok(());
+                }
+            }
+
             // The main window is built here rather than by Tauri from
             // tauri.conf.json, because one of its settings has to differ by
             // platform and the config file has no way to say so. The config
@@ -1254,6 +1280,45 @@ fn app_root_is_writable(root: &Path) -> bool {
     }
 }
 
+/// What the startup check decided about the app root (#746).
+#[cfg(any(windows, target_os = "linux"))]
+#[derive(Debug, PartialEq, Eq)]
+enum PortableRootCheck {
+    Proceed,
+    NotWritable,
+}
+
+/// A portable package keeps its runtime, torch swap and updates inside its own
+/// folder, so it is only usable where the user can write. Installs that are not
+/// portable keep their data elsewhere and are never stopped by this.
+///
+/// The probe is a closure so it only runs for a portable package. It creates a
+/// file in the app root, and on any other install, a root-owned /opt one in
+/// particular, writing there at every start is neither needed nor safe.
+#[cfg(any(windows, target_os = "linux"))]
+fn portable_root_check(portable: bool, probe_writable: impl FnOnce() -> bool) -> PortableRootCheck {
+    if portable && !probe_writable() {
+        PortableRootCheck::NotWritable
+    } else {
+        PortableRootCheck::Proceed
+    }
+}
+
+/// Plain wording, with the folder shown. Elevation is deliberately not offered:
+/// an elevated window cannot receive drag and drop from a normal Explorer
+/// (Windows UIPI), and every launch would prompt.
+#[cfg(any(windows, target_os = "linux"))]
+fn not_writable_message(root: &Path) -> String {
+    format!(
+        "StemDeck cannot write to the folder it is in:\n\n{}\n\n\
+         A portable StemDeck must live in a folder you can write to, for example \
+         C:\\StemDeck. It cannot run from Program Files, and Documents or Desktop \
+         can refuse it too when Windows security protects those folders.\n\n\
+         Move the whole folder there and start StemDeck again.",
+        root.display()
+    )
+}
+
 /// Stops the backend and waits for the process to actually exit.
 ///
 /// The regular `stop_backend` hands the kill to a background thread and
@@ -6948,6 +7013,35 @@ mod tests {
         assert_eq!(fs::read_dir(dir.path()).unwrap().count(), 0);
     }
 
+    // #746: a portable zip extracted under Program Files is not writable
+    // without admin. Only that combination stops startup.
+    #[cfg(any(windows, target_os = "linux"))]
+    #[test]
+    fn only_an_unwritable_portable_root_stops_startup() {
+        use super::{portable_root_check, PortableRootCheck::*};
+        assert_eq!(portable_root_check(true, || false), NotWritable);
+        assert_eq!(portable_root_check(true, || true), Proceed);
+        assert_eq!(portable_root_check(false, || false), Proceed);
+        assert_eq!(portable_root_check(false, || true), Proceed);
+    }
+
+    // The probe writes a file into the app root, so an install that is not
+    // portable must never run it (security review of #746).
+    #[cfg(any(windows, target_os = "linux"))]
+    #[test]
+    fn a_non_portable_install_is_never_probed() {
+        let outcome = super::portable_root_check(false, || panic!("probed a non-portable root"));
+        assert_eq!(outcome, super::PortableRootCheck::Proceed);
+    }
+
+    #[cfg(any(windows, target_os = "linux"))]
+    #[test]
+    fn the_not_writable_message_names_the_folder_and_a_fix() {
+        let msg = super::not_writable_message(Path::new(r"C:\Program Files (x86)\Stemdeck"));
+        assert!(msg.contains("Program Files (x86)"));
+        assert!(msg.contains(r"C:\StemDeck"));
+    }
+
     // install.sh --global puts the package in /opt, root-owned, while the app
     // runs as the user. The updater has to decline up front rather than fail
     // part way through the swap.
diff --git a/packaging/windows/README-WINDOWS.txt b/packaging/windows/README-WINDOWS.txt
index b17a30e9..9b1ee89a 100644
--- a/packaging/windows/README-WINDOWS.txt
+++ b/packaging/windows/README-WINDOWS.txt
@@ -4,7 +4,8 @@ StemDeck Windows Portable Alpha
 Run
 ---
 
-1. Extract the zip folder.
+1. Extract the zip folder to a folder you can write to (for example C:\StemDeck),
+   not Program Files.
 2. Double-click StemDeck.exe.
 3. Let first-run setup prepare local runtime assets.
 
diff --git a/static/css/daw.css b/static/css/daw.css
index b4527f1f..d015e4a0 100644
--- a/static/css/daw.css
+++ b/static/css/daw.css
@@ -578,8 +578,9 @@ input, textarea { font-family: inherit; }
 .rail-btn > span { white-space: nowrap; max-width: 56px; overflow: hidden; text-overflow: ellipsis; }
 
 /* Queue rail button. Only present while something is importing, so the rail
-   stays as it is today for anyone not using the queue. */
-.rail-queue { position: relative; }
+   stays as it is today for anyone not using the queue. The Trash button wears
+   the same badge, with how many songs are in it (#749). */
+.rail-queue, .rail-trash { position: relative; }
 .rail-badge {
   position: absolute; top: 2px; right: 2px;
   min-width: 15px; height: 15px; padding: 0 4px;
@@ -929,6 +930,42 @@ input, textarea { font-family: inherit; }
 .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 stopped song (#748) offers Extract at rest: it is the row's only way on. */
+.cat-item.is-stopped .cat-actions { opacity: 1; pointer-events: auto; }
+
+/* Trash rows look like library rows. On hover the second line becomes the
+   hint, and a hold fills the row from the left over --hold-ms (set from
+   TRASH_HOLD_MS in catalog.js), then restores. */
+.cat-item.in-trash { user-select: none; -webkit-user-select: none; overflow: hidden; }
+.cat-item.in-trash .trash-hint { display: none; color: var(--fg-2); }
+.cat-item.in-trash:hover .trash-hint,
+.cat-item.in-trash:focus-visible .trash-hint,
+.cat-item.in-trash.holding .trash-hint { display: block; overflow: hidden; text-overflow: ellipsis; }
+.cat-item.in-trash:hover .cat-sub:not(.trash-hint),
+.cat-item.in-trash:focus-visible .cat-sub:not(.trash-hint),
+.cat-item.in-trash.holding .cat-sub:not(.trash-hint) { display: none; }
+.trash-hold { position: absolute; inset: 0; pointer-events: none; }
+.trash-hold::before {
+  content: ""; position: absolute; inset: 0;
+  background: color-mix(in srgb, var(--accent) 18%, transparent);
+  transform: scaleX(0); transform-origin: left center;
+}
+.cat-item.in-trash.holding .trash-hold::before {
+  transform: scaleX(1);
+  transition: transform var(--hold-ms, 1000ms) linear;
+}
+.cat-item.in-trash.selected {
+  background: color-mix(in srgb, var(--accent) 10%, transparent);
+  border-color: color-mix(in srgb, var(--accent) 45%, transparent);
+}
+.cat-extract {
+  height: 20px; padding: 0 8px; border: 1px solid var(--accent); border-radius: 5px;
+  background: transparent; color: var(--accent); cursor: pointer;
+  font: inherit; font-size: 11px; white-space: nowrap; flex-shrink: 0;
+  transition: background var(--t-fast), color var(--t-fast);
+}
+.cat-extract:hover, .cat-extract:focus-visible { background: var(--accent); color: var(--panel-2); }
+.cat-extract:disabled { opacity: 0.5; cursor: default; }
 /* 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;
@@ -5632,3 +5669,39 @@ input, textarea { font-family: inherit; }
   box-shadow: 0 12px 32px rgba(0, 0, 0, 0.42);
 }
 .stem-overflow.open { display: flex; }
+
+/* Help mode. The Guide button in the rail, below Trash; while it is pressed,
+   a ring is drawn around what can be seen of the control being explained,
+   and its box sits beside it. The ring is a layer of its own, so nothing in
+   the page moves and no panel clips it. */
+.rail-guide[aria-pressed="true"] { color: var(--accent); background: var(--panel); }
+/* Only the control being explained is marked, so the screen stays calm; the
+   pill at the bottom says help mode is on. */
+.help-mode .help-target { cursor: help; }
+.help-ring {
+  position: fixed; z-index: 9998; pointer-events: none;
+  border: 2px solid var(--accent); border-radius: var(--radius-sm);
+  box-shadow: 0 0 0 4px color-mix(in srgb, var(--accent) 16%, transparent);
+}
+.help-pill {
+  position: fixed; z-index: 9999; left: 50%; bottom: 18px; transform: translateX(-50%);
+  max-width: calc(100vw - 32px);
+  background: var(--panel); border: 1px solid var(--accent); border-radius: 999px;
+  padding: 7px 16px; box-shadow: var(--shadow-panel);
+  color: var(--fg); font: 500 12.5px/1.4 var(--font-sans); text-align: center;
+  pointer-events: none;
+}
+.help-tip {
+  position: fixed; z-index: 10000;
+  width: max-content; max-width: min(300px, calc(100vw - 16px));
+  background: var(--panel); border: 1px solid var(--accent); border-radius: var(--radius);
+  padding: 10px 12px; box-shadow: var(--shadow-panel);
+  color: var(--fg-2); font: 400 13px/1.45 var(--font-sans);
+  pointer-events: none;
+}
+.help-tip b { display: block; margin-bottom: 2px; color: var(--fg); font-size: 13.5px; font-weight: 700; }
+.help-tip.long { max-width: min(560px, calc(100vw - 16px)); columns: 2 230px; column-gap: 20px; font-size: 12px; line-height: 1.4; }
+.help-tip.long b { column-span: all; margin-bottom: 6px; }
+.help-tip-h { break-after: avoid; margin-top: 8px; color: var(--accent); font-size: 10px; font-weight: 700; letter-spacing: 0.1em; text-transform: uppercase; }
+.help-tip-row { break-inside: avoid; margin-top: 3px; }
+.help-tip-row span { color: var(--fg); font-weight: 600; }
diff --git a/static/index.html b/static/index.html
index 7baf25c0..c863c3af 100644
--- a/static/index.html
+++ b/static/index.html
@@ -323,11 +323,21 @@
               <span data-i18n="nav.queue">Queue</span>
               <span class="rail-badge hidden" id="queueBadge" aria-hidden="true"></span>
             </button>
-            <button class="rail-btn rail-trash" type="button" title="Trash" aria-label="Trash" aria-pressed="false" data-i18n-title="nav.trash" data-i18n-aria-label="nav.trash">
+            <button class="rail-btn rail-trash" type="button" title="Trash" aria-label="Trash" aria-pressed="false">
               <svg width="18" height="18" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.6" aria-hidden="true">
                 <path d="M3 6h18 M8 6V4h8v2 M19 6l-1 14H6L5 6"/>
               </svg>
               <span data-i18n="nav.trash">Trash</span>
+              <span class="rail-badge hidden" id="trashBadge" aria-hidden="true"></span>
+            </button>
+            <!-- Help mode: the screen explains itself while this is pressed. -->
+            <button class="rail-btn rail-guide" type="button" id="helpModeBtn" aria-pressed="false"
+                    title="Explain the screen" aria-label="Explain the screen"
+                    data-i18n-title="help.button" data-i18n-aria-label="help.button">
+              <svg width="18" height="18" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.6" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true">
+                <path d="M2 5.5c3-1.3 6-1.3 10 1v13c-4-2.3-7-2.3-10-1z M22 5.5c-3-1.3-6-1.3-10 1v13c4-2.3 7-2.3 10-1z"/>
+              </svg>
+              <span data-i18n="help.railLabel">Guide</span>
             </button>
             <div style="flex:1"></div>
             <!-- Notifications (#636). In the rail rather than at the end
diff --git a/static/js/catalog.js b/static/js/catalog.js
index 8fae4f6a..06231b0e 100644
--- a/static/js/catalog.js
+++ b/static/js/catalog.js
@@ -2,14 +2,14 @@
 import { STEM_NAMES } from "./constants.js";
 import { wireUpAudio, updateFooterTrack } from "./player.js";
 import { initSections } from "./sections.js";
-import { bpmChip, foregroundJobId, keyChip, saveSelectedStems, selectedStems, titleEl } from "./state.js";
+import { audioEngine, bpmChip, foregroundJobId, keyChip, multitrack, saveSelectedStems, selectedStems, titleEl } from "./state.js";
 import { refreshStemChoiceVisuals } from "./stemChoice.js";
 import { trackFormat, formatIconSvg, paintNowPlayingArt } from "./formatIcon.js";
 import { formatKey } from "./keyLabel.js";
 import { showError, importFromUrl, detachForegroundJob, runVocalSplitIfWanted } from "./job.js";
 import {
-  cancelQueuedJob, getQueueSnapshot, isPaused, onJobSettled, onQueueChange,
-  queueCount, queueRowStates, reorderQueuedJob, runningLabel, startQueue,
+  cancelQueuedJob, currentIds, getQueueSnapshot, isPaused, onJobSettled, onQueueChange,
+  queueCount, queueRowStates, refreshQueue, reorderQueuedJob, runningLabel, startQueue,
   startQueueStream,
 } from "./queue.js";
 import { fmtTime, isReimportableSource, storeGet, storeSet } from "./utils.js";
@@ -211,8 +211,18 @@ let _currentTrackId = null;
 // The open track's tags as the last render() saw them. See setCurrentTrack().
 let _renderedTagsKey = "";
 let _loadTrackToken = 0;
+// Imports submitted from the form, mapped to the load token at that moment. A
+// finished one opens in the studio only if nothing has been opened since (#747).
+const _autoOpenTokens = new Map();
 let catalogView = "library";
 let catalogSearchQuery = "";
+// Rows picked in the Trash with a click, Ctrl or Shift. A hold on one of them
+// restores them all. The anchor is where the next Shift+click range starts.
+const _trashSelection = new Set();
+let _trashAnchor = null;
+// How long a Trash row has to be held to restore it. daw.css reads it through
+// --hold-ms, so the fill and the timer cannot drift apart.
+const TRASH_HOLD_MS = 1000;
 
 // ─── Persistence ───
 
@@ -220,6 +230,13 @@ const TRASH_ID = "trash";
 // The default landing folder for unorganized tracks — protected from deletion.
 const UNSORTED_ID = "f-unsorted";
 const PROCESSING_STATUSES = new Set(["queued", "downloading", "analyzing", "separating", "processing"]);
+
+// One trash can for every "throw this away" button: the library rows and the
+// queue rows (#748), so the queue's cancel reads as the same action.
+const TRASH_ICON_SVG = `<svg viewBox="0 0 24 24" width="12" height="12" fill="none" stroke="currentColor" stroke-width="2" aria-hidden="true">
+        <polyline points="3 6 5 6 21 6"></polyline>
+        <path d="M19 6v14a2 2 0 0 1-2 2H7a2 2 0 0 1-2-2V6m3 0V4a1 1 0 0 1 1-1h4a1 1 0 0 1 1 1v2"></path>
+      </svg>`;
 const FOLDER_COLORS = ["#d8a84a", "#e85f6f", "#64c86f", "#4f9de8", "#a985f4"];
 const DEFAULT_FOLDER_COLOR = FOLDER_COLORS[0];
 const TRACK_DRAG_TYPE = "application/x-stemdeck-track";
@@ -690,6 +707,8 @@ export function updateTrackStatus(trackId, status) {
     for (const el of document.querySelectorAll(`.cat-item[data-id="${trackId}"]`)) {
       el.classList.toggle("unavailable", status === "unavailable");
     }
+    // A stopped row changes its line and gains Extract (#748), more than a dot.
+    if (status === "stopped") render();
   }
 }
 
@@ -938,7 +957,7 @@ function applyTrackInfoToPanel(track) {
  */
 function syncTrashToServer(trackId, trashed) {
   const action = trashed ? "trash" : "restore";
-  fetch(`/api/jobs/${encodeURIComponent(trackId)}/${action}`, { method: "POST" })
+  return fetch(`/api/jobs/${encodeURIComponent(trackId)}/${action}`, { method: "POST" })
     .catch((e) => console.warn(`[catalog] could not ${action} ${trackId} on the server`, e));
 }
 
@@ -987,7 +1006,13 @@ function moveTrackToTrash(trackId) {
   // purgeTrash() does the same on permanent delete, for a job that errors
   // after being trashed but before it's purged.
   dismissFailuresByJobId(trackId);
-  syncTrashToServer(trackId, true);
+  // The server stops a job that is still importing when it is trashed, its
+  // files kept (#748). Ask for the queue again once it has, so the row goes now rather
+  // than whenever the next frame happens to arrive.
+  const wasInQueue = currentIds(getQueueSnapshot()).has(trackId);
+  syncTrashToServer(trackId, true).then(() => {
+    if (wasInQueue) refreshQueue();
+  });
   saveState();
   render();
 }
@@ -999,6 +1024,7 @@ function setCatalogView(view) {
   // the collapse button's aria-expanded is left claiming the sidebar is still
   // shut.
   if (catalogView !== "library") setSidebarCollapsed(false);
+  if (catalogView !== "trash") clearTrashSelection();
   render();
   // The lyrics panel (lyrics.js) draws itself; this is how it learns it is on
   // screen, without catalog.js importing it.
@@ -1553,22 +1579,145 @@ function wireRailTrashDrop() {
   });
 }
 
-function restoreTrackFromTrash(trackId) {
-  if (!tracks[trackId]) return;
+/** Take tracks back out of the Trash, with one save and one render however
+ *  many there are. Restore never queues a song again (#748): a stopped one
+ *  comes back stopped, with its Extract button. */
+function restoreTracksFromTrash(trackIds) {
   const trash = getTrashFolder();
-  if (!trash?.items.includes(trackId)) return;
-  trash.items = trash.items.filter((id) => id !== trackId);
+  const ids = trackIds.filter((id) => tracks[id] && trash?.items.includes(id));
+  if (!ids.length) return;
+  trash.items = trash.items.filter((id) => !ids.includes(id));
   let target = folders.find((f) => f.id !== TRASH_ID);
   if (!target) {
     target = makeFolder({ id: "f-unsorted", name: "Unsorted" });
     folders.unshift(target);
   }
-  if (!target.items.includes(trackId)) target.items.push(trackId);
-  syncTrashToServer(trackId, false);
+  for (const id of ids) {
+    _trashSelection.delete(id);
+    if (!target.items.includes(id)) target.items.push(id);
+    syncTrashToServer(id, false);
+  }
   saveState();
   render();
 }
 
+/** The rows a gesture on this one acts on: the whole selection when the row
+ *  is part of it, otherwise the row alone. */
+function trashTargets(trackId) {
+  return _trashSelection.has(trackId) ? [..._trashSelection] : [trackId];
+}
+
+function clearTrashSelection() {
+  _trashSelection.clear();
+  _trashAnchor = null;
+}
+
+function paintTrashSelection() {
+  for (const el of document.querySelectorAll(".cat-item.in-trash")) {
+    const selected = _trashSelection.has(el.dataset.id);
+    el.classList.toggle("selected", selected);
+    el.setAttribute("aria-selected", String(selected));
+  }
+}
+
+/** Click picks rows: alone, Ctrl (Cmd on a Mac) adds or removes one, Shift
+ *  takes the range from the last row picked, in the order on screen. */
+function selectTrashRow(trackId, e) {
+  if (e.shiftKey && _trashAnchor) {
+    const order = [...document.querySelectorAll(".cat-item.in-trash")].map((el) => el.dataset.id);
+    const from = order.indexOf(_trashAnchor);
+    const to = order.indexOf(trackId);
+    if (from !== -1 && to !== -1) {
+      if (!(e.ctrlKey || e.metaKey)) _trashSelection.clear();
+      const [a, b] = from < to ? [from, to] : [to, from];
+      for (const id of order.slice(a, b + 1)) _trashSelection.add(id);
+      paintTrashSelection();
+      return;
+    }
+  }
+  if (e.ctrlKey || e.metaKey) {
+    if (_trashSelection.has(trackId)) _trashSelection.delete(trackId);
+    else _trashSelection.add(trackId);
+  } else {
+    _trashSelection.clear();
+    _trashSelection.add(trackId);
+  }
+  _trashAnchor = trackId;
+  paintTrashSelection();
+}
+
+/** A Trash row: click selects, holding for TRASH_HOLD_MS restores it (or the
+ *  selection it belongs to), and dragging it onto Library still restores. A
+ *  click no longer opens the song: every hold let go early would do that. */
+function wireTrashRow(el, trackId) {
+  el.draggable = true;
+  el.tabIndex = 0;
+  el.style.setProperty("--hold-ms", `${TRASH_HOLD_MS}ms`);
+  let timer = null;
+  let restored = false;
+  // Every row the hold will restore fills together, so a selection shows as
+  // one gesture rather than only the row under the pointer.
+  let held = [];
+  const cancel = () => {
+    clearTimeout(timer);
+    timer = null;
+    for (const row of held) row.classList.remove("holding");
+    held = [];
+  };
+  const start = () => {
+    cancel();
+    restored = false;
+    const targets = new Set(trashTargets(trackId));
+    held = [...document.querySelectorAll(".cat-item.in-trash")].filter((row) => targets.has(row.dataset.id));
+    if (!held.includes(el)) held.push(el);
+    for (const row of held) row.classList.add("holding");
+    timer = setTimeout(() => {
+      timer = null;
+      restored = true;
+      for (const row of held) row.classList.remove("holding");
+      held = [];
+      restoreTracksFromTrash([...targets]);
+    }, TRASH_HOLD_MS);
+  };
+  el.addEventListener("pointerdown", (e) => {
+    // Ctrl and Shift are for picking rows, not for restoring them.
+    if (e.button !== 0 || e.ctrlKey || e.metaKey || e.shiftKey) return;
+    start();
+  });
+  for (const type of ["pointerup", "pointerleave", "pointercancel"]) el.addEventListener(type, cancel);
+  el.addEventListener("keydown", (e) => {
+    if ((e.key === "Enter" || e.key === " ") && !e.repeat) {
+      e.preventDefault();
+      start();
+    }
+  });
+  el.addEventListener("keyup", (e) => {
+    if (e.key === "Enter" || e.key === " ") cancel();
+  });
+  el.addEventListener("click", (e) => {
+    if (restored) return;
+    selectTrashRow(trackId, e);
+  });
+  el.addEventListener("dragstart", (e) => {
+    cancel();
+    startDrag(trackId, el, e);
+  });
+  el.addEventListener("dragend", () => endDrag(el));
+}
+
+/** The Trash shows how full it is (#749): the reporter never noticed it was
+ *  there, so nothing told them their deleted songs were still on disk. */
+function updateTrashBadge(count = getTrashFolder()?.items.length ?? 0) {
+  const btn = document.querySelector(".rail-trash");
+  const badge = document.getElementById("trashBadge");
+  if (!btn || !badge) return;
+  badge.textContent = count > 99 ? "99+" : String(count);
+  badge.classList.toggle("hidden", count === 0);
+  const label = count ? i18nT("nav.trashWithCount", { count }) : i18nT("nav.trash");
+  btn.title = label;
+  btn.setAttribute("aria-label", label);
+}
+
 function wireRailLibraryDrop() {
   const btn = document.querySelector(".rail-library");
   if (!btn || btn.dataset.dropReady === "1") return;
@@ -1589,7 +1738,7 @@ function wireRailLibraryDrop() {
     const trackId = getDraggedTrackId(e);
     if (!trackId || !tracks[trackId]) return;
     e.preventDefault();
-    restoreTrackFromTrash(trackId);
+    restoreTracksFromTrash(trashTargets(trackId));
     setCatalogView("library");
   });
 }
@@ -1684,6 +1833,8 @@ function trackSublineHtml(track, { inTrash = false } = {}) {
     parts = [i18nT("job.processing")];
   } else if (track.status === "error") {
     parts = [i18nT("notifKind.importFailed")];
+  } else if (track.status === "stopped") {
+    parts = [i18nT("track.stopped")];
   } else {
     // Just the length. The stem count was here too, but every row carrying
     // "6 stems" says the same thing forty times over, and the now-playing card
@@ -1768,27 +1919,54 @@ function makeStripItem({ className = "", id, title, html, color, trackId }) {
   return item;
 }
 
+// A song stopped by the Trash keeps its files (#748). Restore brings it back
+// as it was, and this is the one way to run it again: the user decides when it
+// gets the GPU, never Restore and never a reload.
+function extractButtonHtml(track) {
+  const label = i18nT("track.extractAgainOf", { title: displayTitle(track.title) });
+  return `<button class="cat-extract" type="button" title="${esc(i18nT("track.extractAgain"))}"
+            aria-label="${esc(label)}">${esc(i18nT("track.extractAgain"))}</button>`;
+}
+
+async function extractStoppedTrack(trackId) {
+  try {
+    const res = await fetch(`/api/jobs/${encodeURIComponent(trackId)}/extract`, { method: "POST" });
+    if (!res.ok) {
+      const body = await res.json().catch(() => ({}));
+      notifyFailure({ kind: "import", message: body.detail || i18nT("job.audioProcessingFailed") });
+      render();
+      return;
+    }
+    if (tracks[trackId]) tracks[trackId].status = "queued";
+    // Like any import (#747): it opens when done, if the studio is still empty.
+    armAutoOpen(trackId);
+    saveState();
+    render();
+    await refreshQueue();
+  } catch (e) {
+    console.warn("[catalog] could not extract", trackId, e);
+    render();
+  }
+}
+
 function renderTrackItem(trackId, { inTrash = false } = {}) {
   const track = tracks[trackId];
   if (!track) return null;
 
   const el = document.createElement("div");
   const isUnavailable = track.status === "unavailable";
-  el.className = `cat-item${trackId === _currentTrackId ? " active" : ""}${isUnavailable ? " unavailable" : ""}${!inTrash && track.favorite ? " is-fav" : ""}`;
+  el.className = `cat-item${trackId === _currentTrackId ? " active" : ""}${isUnavailable ? " unavailable" : ""}${!inTrash && track.favorite ? " is-fav" : ""}${!inTrash && track.status === "stopped" ? " is-stopped" : ""}${inTrash ? " in-trash" : ""}${inTrash && _trashSelection.has(trackId) ? " selected" : ""}`;
   el.dataset.id = trackId;
 
   el.innerHTML = `
     <div class="cat-thumb">${thumbHtml(track)}</div>
     <div class="cat-meta">
       <div class="cat-title">${esc(displayTitle(track.title))}</div>
-      <div class="cat-sub">${trackSublineHtml(track, { inTrash })}</div>
+      <div class="cat-sub">${trackSublineHtml(track, { inTrash })}</div>${inTrash ? `<div class="cat-sub trash-hint">${esc(i18nT("trash.holdToRestore"))}</div>` : ""}
     </div>
     <div class="cat-status${PROCESSING_STATUSES.has(track.status) ? " processing" : isUnavailable ? " unavailable" : ""}"></div>
-    ${inTrash ? "" : `<div class="cat-actions">${favButtonHtml(track)}<button class="cat-del" type="button" title="${esc(i18nT("track.moveToTrash"))}">
-      <svg viewBox="0 0 24 24" width="12" height="12" fill="none" stroke="currentColor" stroke-width="2" aria-hidden="true">
-        <polyline points="3 6 5 6 21 6"></polyline>
-        <path d="M19 6v14a2 2 0 0 1-2 2H7a2 2 0 0 1-2-2V6m3 0V4a1 1 0 0 1 1-1h4a1 1 0 0 1 1 1v2"></path>
-      </svg>
+    ${inTrash ? `<div class="trash-hold" aria-hidden="true"></div>` : `<div class="cat-actions">${track.status === "stopped" ? extractButtonHtml(track) : ""}${favButtonHtml(track)}<button class="cat-del" type="button" title="${esc(i18nT("track.moveToTrash"))}">
+      ${TRASH_ICON_SVG}
     </button></div>`}
   `;
   el.querySelector(".cat-del")?.setAttribute("aria-label", i18nT("track.moveTitleToTrash", { title: track.title ?? i18nT("track.unknown") }));
@@ -1797,9 +1975,20 @@ function renderTrackItem(trackId, { inTrash = false } = {}) {
     e.stopPropagation();
     moveTrackToTrash(trackId);
   });
+  el.querySelector(".cat-extract")?.addEventListener("click", (e) => {
+    e.stopPropagation();
+    e.currentTarget.disabled = true;
+    extractStoppedTrack(trackId);
+  });
   wireFavButton(el, trackId);
 
-  wireTrackDragAndLoad(el, trackId);
+  if (inTrash) {
+    el.title = i18nT("trash.holdToRestore");
+    el.setAttribute("aria-selected", String(_trashSelection.has(trackId)));
+    wireTrashRow(el, trackId);
+  } else {
+    wireTrackDragAndLoad(el, trackId);
+  }
 
   return el;
 }
@@ -2025,6 +2214,8 @@ function render() {
 
   const trash = getTrashFolder();
   const trashIds = new Set(trash?.items || []);
+  for (const id of _trashSelection) if (!trashIds.has(id)) _trashSelection.delete(id);
+  updateTrashBadge(trashIds.size);
   const isTrashView = catalogView === "trash";
   const isFavoritesView = catalogView === "favorites";
   const isQueueView = catalogView === "queue";
@@ -2232,6 +2423,25 @@ function decorateRow(el, rowState) {
   if (fill) fill.style.width = `${Math.round(rowState.progress * 100)}%`;
 }
 
+/** Remember that this import was started with the studio as it is now. Imports
+ *  never take the studio while they run (#747); this is what lets the first one
+ *  to finish open itself, but only while the studio is still empty and the user
+ *  has not opened anything since. */
+export function armAutoOpen(jobId) {
+  _autoOpenTokens.set(jobId, _loadTrackToken);
+}
+
+/** True when the studio shows no track and no load is under way. Either engine
+ *  counts: the Web Audio path sets audioEngine, the streaming path sets
+ *  multitrack. A load in flight has bumped the token before it has an engine.
+ *  "Sync again" holds the studio through foregroundJobId without either: it
+ *  tears the player down and shows its own overlay, so it counts as busy too. */
+function shouldAutoOpen(jobId) {
+  const armedAt = _autoOpenTokens.get(jobId);
+  _autoOpenTokens.delete(jobId);
+  return armedAt === _loadTrackToken && !audioEngine && !multitrack && !foregroundJobId;
+}
+
 /** A background import has finished (or failed, or was cancelled). It has no
  *  per-job stream, so fetch its final state once and complete its library entry
  *  -- stems, duration and analysis all land here, which is what makes the track
@@ -2248,6 +2458,7 @@ async function completeSettledJob(jobId) {
     }
     const state = await res.json();
     if (state.status === "cancelled") {
+      _autoOpenTokens.delete(jobId);
       // Nothing was produced; drop the placeholder row rather than leaving a
       // track that can never be loaded.
       delete tracks[jobId];
@@ -2282,7 +2493,14 @@ async function completeSettledJob(jobId) {
     const finalState = state.status === "done" ? await runVocalSplitIfWanted(state) : state;
     const track = stateMetadataToTrack(finalState, { ...existing, id: jobId });
     track.id = jobId;
+    // A server that sends "work" looked for it while the job ran, so the track
+    // that opens next never needs to ask again (#747: every import lands here).
+    if (finalState.status === "done" && "work" in finalState) track.workChecked = true;
     addTrackToLibrary(track);
+    // Checked after the split so the stems it makes are there when it opens,
+    // and through the library's own loader so it behaves like a click on the row.
+    if (finalState.status === "done" && shouldAutoOpen(jobId)) loadTrackIntoStudio(jobId);
+    else _autoOpenTokens.delete(jobId);
   } catch (e) {
     console.warn("[catalog] could not finish background job", jobId, e);
   }
@@ -2329,9 +2547,7 @@ function queueRowHtml({ job, running }, place, { paused = false } = {}) {
       </button>`}
       <button class="queue-cancel" type="button" title="${esc(i18nT("queue.cancelImport"))}"
               aria-label="${esc(i18nT("queue.cancelImportOf", { title: displayTitle(job.title || job.source_url) }))}">
-        <svg viewBox="0 0 24 24" width="12" height="12" fill="none" stroke="currentColor" stroke-width="2.2" aria-hidden="true">
-          <path d="M18 6 6 18 M6 6l12 12"></path>
-        </svg>
+        ${TRASH_ICON_SVG}
       </button>
     </div>`;
 }
@@ -3540,9 +3756,26 @@ async function syncWithServer() {
       if (favBtn && current) paintFavButton(favBtn, Boolean(current.favorite));
     }
     reconcileAvailability(jobs);
+    settleStaleProcessingTracks();
   } catch (e) { console.warn("[catalog] failed to load jobs from backend:", e); }
 }
 
+/**
+ * Ask the server where every track this side still calls "processing" stands.
+ *
+ * A job is only settled here when it leaves the queue while the page watches
+ * it. One that stopped, failed or finished while the app was closed never left
+ * the queue in front of this page, so its row said "processing" for good: the
+ * song trashed mid-extraction in #748 sat in the Trash that way after a
+ * restart. completeSettledJob takes whatever the server says, so a job that
+ * really is still waiting just keeps its status.
+ */
+function settleStaleProcessingTracks() {
+  for (const [id, track] of Object.entries(tracks)) {
+    if (PROCESSING_STATUSES.has(track.status)) completeSettledJob(id);
+  }
+}
+
 // ─── Settings menu + Library editor ───
 
 let libraryEditor = null;
@@ -4903,7 +5136,7 @@ async function waitForJobTerminal(jobId) {
       const r = await fetch(`/api/jobs/${jobId}`, { cache: "no-store" });
       if (r.status === 404) return;
       const s = await r.json();
-      if (s.status === "done" || s.status === "error" || s.status === "cancelled") return;
+      if (["done", "error", "cancelled", "stopped"].includes(s.status)) return;
     } catch { /* transient — keep waiting */ }
   }
 }
diff --git a/static/js/helpMode.js b/static/js/helpMode.js
new file mode 100644
index 00000000..767b07e8
--- /dev/null
+++ b/static/js/helpMode.js
@@ -0,0 +1,336 @@
+// Help mode: Guide in the rail, below Trash, turns the studio into its own manual.
+// Pointing at any control listed in HELP, or clicking it, outlines it and shows
+// what it does; a pill at the bottom says help mode is on. Clicks are taken by help mode while it is on,
+// so exploring never starts an extraction or deletes a song. Esc or Guide
+// again turns it off.
+//
+// The box is titled with the control's own label, which the rest of the app
+// already translates, and its text comes from the help.* keys in i18n.js.
+
+import { t } from "./i18n.js";
+
+/** Lane controls name their instrument in the text ("Silences the Drums"). */
+const laneName = (el) => el.closest(".mx-row, .lane-header")?.querySelector(".mx-name")?.textContent.trim() || "";
+const chipName = (el) => el.textContent.trim();
+
+// Order matters only where selectors overlap: the first match wins.
+const HELP = [
+  ["#helpModeBtn", "help.helpMode"],
+  [".daw-brand a", "help.website"],
+  ["#uploadFileBtn", "help.upload"],
+  ["#url", "help.search"],
+  ["#stemAllBtn", "help.stemAll"],
+  [".stem-choice[data-stem]", "help.stemChip", chipName],
+  ['.vocal-mode-btn[data-mode="all"]', "help.vocalCombined"],
+  ['.vocal-mode-btn[data-mode="split"]', "help.vocalSplit"],
+  ["#autoSectionsBtn", "help.detectStructure"],
+  ['.daw-panel-toggle[data-panel="analysis"]', "help.analysisToggle"],
+  ['.daw-panel-toggle[data-panel="sections"]', "help.sectionsToggle"],
+  ["#submit", "help.extract"],
+  ["#fav-btn", "help.favorite"],
+  ["#np-details-btn", "help.songDetails"],
+  ["#sidebarCollapseBtn", "help.toggleLibrary"],
+  [".rail-favorites", "help.favorites"],
+  [".rail-library", "help.library"],
+  [".rail-lyrics", "help.lyrics"],
+  [".rail-trash", "help.trash"],
+  [".rail-queue", "help.queue"],
+  ["#notifBtn", "help.notifications"],
+  ["#friendsBtn", "help.recommend"],
+  ["#settingsBtn", "settings"],
+  ["#aboutBtn", "help.about"],
+  ["#catalogSearch", "help.searchLibrary"],
+  ["#newFolderBtn", "help.newFolder"],
+  ["#catalogList .cat-item.in-trash", "help.trashedSong"],
+  ["#catalogList .cat-item", "help.song"],
+  ["#sectionsAddBtn", "help.addSection"],
+  [".mx-fader", "help.volume", laneName],
+  [".lane-key-step.up", "help.laneKeyUp", laneName],
+  [".lane-key-step.down", "help.laneKeyDown", laneName],
+  [".lane-key-value", "help.laneKey", laneName, "help.laneKeyTitle"],
+  [".mx-btn.mute", "help.mute", laneName],
+  [".mx-btn.solo", "help.solo", laneName],
+  [".lane-dl", "help.download", laneName],
+  ["#transport .daw-info-row", "help.songFacts", null, "help.songFactsTitle"],
+  ["#ruler-time", "help.waves", null, "help.wavesTitle"],
+  [".waves-column", "help.waves", null, "help.wavesTitle"],
+  ["#t-stop", "help.stop"],
+  ["#t-play", "help.play"],
+  ["#t-loop", "help.loop"],
+  ["#t-loop-start", "help.loopStart"],
+  ["#t-loop-end", "help.loopEnd"],
+  ["#t-speed-05", "help.speedHalf"],
+  ["#t-speed-075", "help.speedSlow"],
+  ["#t-speed-1", "help.speedNormal"],
+  ["#t-pitch-down", "help.keyDown"],
+  ["#t-pitch-up", "help.keyUp"],
+  ["#t-pitch-reset", "help.keyReset"],
+  ["#t-metro", "help.click"],
+  ["#t-metro-vol-btn", "help.clickVolume"],
+  ["#t-metro-more", "help.clickMore"],
+  ["#t-export-btn", "help.export"],
+];
+
+// Every option in Settings, by tab: the tab and option names are the dialog's
+// own keys, the one-line descriptions are help.set.*.
+const SETTINGS = [
+  ["settings.tab.general", [
+    ["settings.language.title", "help.set.language"],
+    ["settings.maxDuration.title", "help.set.maxDuration"],
+    ["settings.playlistLimit.title", "help.set.playlistLimit"],
+    ["settings.cookies.title", "help.set.cookies"],
+    ["settings.stemsLocation.title", "help.set.stemsLocation"],
+    ["settings.exportsLocation.title", "help.set.exportsLocation"],
+    ["settings.autoDelete.title", "help.set.autoDelete"],
+    ["settings.device.title", "help.set.device"],
+    ["settings.quality.title", "help.set.quality"],
+    ["settings.exportLogs.title", "help.set.exportLogs"],
+    ["settings.resetData.title", "help.set.resetData"],
+  ]],
+  ["settings.tab.songDetails", [
+    ["settings.acoustid.title", "help.set.acoustid"],
+    ["settings.discogs.title", "help.set.discogs"],
+    ["settings.transcribe.title", "help.set.transcribe"],
+  ]],
+  ["settings.tab.network", [
+    ["settings.network.allowTitle", "help.set.network"],
+    ["settings.network.port.title", "help.set.port"],
+  ]],
+  ["settings.tab.export", [
+    ["settings.export.sampleRate.title", "help.set.sampleRate"],
+    ["settings.export.videoQuality.title", "help.set.videoQuality"],
+  ]],
+  ["settings.tab.logs", [[null, "help.set.logs"]]],
+  ["settings.tab.registry", [[null, "help.set.registry"]]],
+];
+
+let on = false;
+let tipEl = null;
+let pillEl = null;
+let ringEl = null;
+let current = null;
+
+export function isHelpModeOn() {
+  return on;
+}
+
+/** The help entry for whatever is under the pointer, and the element it is for. */
+function findEntry(target) {
+  if (!(target instanceof Element)) return null;
+  for (const [sel, key, nameOf, titleKey] of HELP) {
+    const el = target.closest(sel);
+    if (el && isVisible(el)) return { el, key, nameOf, titleKey };
+  }
+  return null;
+}
+
+function isVisible(el) {
+  const r = el.getBoundingClientRect();
+  return r.width > 0 && r.height > 0;
+}
+
+/** The control's own label, which the app already translates. Visible text
+ *  first, unless it is a letter or a sign (M, S, +): a heading that repeats
+ *  "M" teaches nothing, so those take their full label ("Mute Drums"). */
+function titleOf(entry) {
+  const { el } = entry;
+  if (entry.titleKey) return t(entry.titleKey, { name: entry.nameOf ? entry.nameOf(el) : "" });
+  const text = (el.innerText || "").trim().split("\n")[0].trim();
+  if (text.length > 2 && text.length <= 40) return text;
+  return el.getAttribute("aria-label") || el.getAttribute("placeholder") || el.getAttribute("title")
+    || el.querySelector("[aria-label]")?.getAttribute("aria-label") || text;
+}
+
+function fillTip(entry) {
+  tipEl.replaceChildren();
+  tipEl.classList.toggle("long", entry.key === "settings");
+  const title = document.createElement("b");
+  title.textContent = titleOf(entry);
+  tipEl.append(title);
+  if (entry.key !== "settings") {
+    const name = entry.nameOf ? entry.nameOf(entry.el) : "";
+    tipEl.append(t(entry.key, { name }));
+    return;
+  }
+  for (const [tabKey, rows] of SETTINGS) {
+    const h = document.createElement("div");
+    h.className = "help-tip-h";
+    h.textContent = t(tabKey);
+    tipEl.append(h);
+    for (const [nameKey, descKey] of rows) {
+      const row = document.createElement("div");
+      row.className = "help-tip-row";
+      if (nameKey) {
+        const n = document.createElement("span");
+        n.textContent = t(nameKey);
+        row.append(n, " ");
+      }
+      row.append(t(descKey));
+      tipEl.append(row);
+    }
+  }
+}
+
+/**
+ * What the eye sees of a control. A button is often much bigger than the icon
+ * in it (the heart is a 76px tall strip around a 16px icon), and a ring around
+ * the whole box reads as a stray bar. When the content is clearly smaller than
+ * the box, the ring goes around the content instead.
+ */
+function visibleRect(el) {
+  const r = el.getBoundingClientRect();
+  const range = document.createRange();
+  range.selectNodeContents(el);
+  const c = range.getBoundingClientRect();
+  const small = c.width > 0 && c.height > 0 && (c.width < r.width * 0.6 || c.height < r.height * 0.6);
+  // Otherwise the box and its content together: a rail label can hang below
+  // its button's own box, and the ring has to take it in.
+  const box = small ? c : c.width > 0 && c.height > 0
+    ? { left: Math.min(r.left, c.left), top: Math.min(r.top, c.top), right: Math.max(r.right, c.right), bottom: Math.max(r.bottom, c.bottom) }
+    : r;
+  const pad = small ? 6 : 3;
+  const left = box.left - pad, top = box.top - pad, right = box.right + pad, bottom = box.bottom + pad;
+  return { left, top, right, bottom, width: right - left, height: bottom - top };
+}
+
+/** The ring is its own layer over the page, so no panel can clip it. */
+function placeRing(rect) {
+  ringEl.style.left = `${Math.round(rect.left)}px`;
+  ringEl.style.top = `${Math.round(rect.top)}px`;
+  ringEl.style.width = `${Math.round(rect.right - rect.left)}px`;
+  ringEl.style.height = `${Math.round(rect.bottom - rect.top)}px`;
+  ringEl.hidden = false;
+}
+
+/** Beside the control, on whichever side has room, never over it. */
+function placeTip(r) {
+  const tr = tipEl.getBoundingClientRect();
+  const vw = window.innerWidth, vh = window.innerHeight, gap = 10, m = 8;
+  const fits = (x, y) => x >= m && y >= m && x + tr.width <= vw - m && y + tr.height <= vh - m;
+  const cx = Math.min(Math.max(m, r.left + r.width / 2 - tr.width / 2), vw - tr.width - m);
+  const cy = Math.min(Math.max(m, r.top + r.height / 2 - tr.height / 2), vh - tr.height - m);
+  const options = [
+    [r.right + gap, cy],
+    [r.left - gap - tr.width, cy],
+    [cx, r.bottom + gap],
+    [cx, r.top - gap - tr.height],
+  ];
+  // A large area, like the waveforms, takes the box inside its top edge.
+  const [x, y] = options.find(([x, y]) => fits(x, y)) ?? [cx, Math.max(m, Math.min(r.top + 12, vh - tr.height - m))];
+  tipEl.style.left = `${Math.round(x)}px`;
+  tipEl.style.top = `${Math.round(y)}px`;
+}
+
+function show(entry) {
+  if (current?.el === entry.el) return;
+  hide();
+  current = entry;
+  entry.el.classList.add("help-current");
+  fillTip(entry);
+  tipEl.hidden = false;
+  const rect = visibleRect(entry.el);
+  placeRing(rect);
+  placeTip(rect);
+}
+
+function hide() {
+  current?.el.classList.remove("help-current");
+  current = null;
+  if (tipEl) tipEl.hidden = true;
+  if (ringEl) ringEl.hidden = true;
+}
+
+/** Mark everything help mode can explain, including lanes added since. */
+function markTargets() {
+  for (const el of document.querySelectorAll(".help-target")) el.classList.remove("help-target");
+  if (!on) return;
+  for (const [sel] of HELP) {
+    for (const el of document.querySelectorAll(sel)) if (isVisible(el)) el.classList.add("help-target");
+  }
+}
+
+function onPointerOver(e) {
+  const entry = findEntry(e.target);
+  if (entry) show(entry);
+  else if (!tipEl.contains(e.target)) hide();
+}
+
+// Help mode takes every press except Guide itself, so pointing around the
+// studio can never act on it. A click shows that control's box, which is also
+// how help mode works on a touch screen.
+function swallow(e) {
+  if (e.target instanceof Element && e.target.closest("#helpModeBtn")) return;
+  e.preventDefault();
+  e.stopPropagation();
+  if (e.type === "click") {
+    const entry = findEntry(e.target);
+    if (entry) show(entry);
+    else hide();
+  }
+}
+
+function onFocus(e) {
+  const entry = findEntry(e.target);
+  if (entry) show(entry);
+}
+
+function onKey(e) {
+  if (e.key === "Escape") {
+    e.preventDefault();
+    e.stopPropagation();
+    setHelpMode(false);
+  }
+}
+
+const PRESS_EVENTS = ["pointerdown", "mousedown", "click", "dblclick", "dragstart", "contextmenu"];
+
+export function setHelpMode(next) {
+  if (next === on) return;
+  on = next;
+  document.body.classList.toggle("help-mode", on);
+  if (pillEl) {
+    pillEl.textContent = t("help.pill");
+    pillEl.hidden = !on;
+  }
+  const btn = document.getElementById("helpModeBtn");
+  btn?.setAttribute("aria-pressed", String(on));
+  if (on) {
+    document.addEventListener("pointerover", onPointerOver, true);
+    for (const type of PRESS_EVENTS) document.addEventListener(type, swallow, true);
+    document.addEventListener("keydown", onKey, true);
+    document.addEventListener("focusin", onFocus, true);
+    window.addEventListener("resize", hide);
+    document.addEventListener("scroll", hide, true);
+    markTargets();
+  } else {
+    document.removeEventListener("pointerover", onPointerOver, true);
+    for (const type of PRESS_EVENTS) document.removeEventListener(type, swallow, true);
+    document.removeEventListener("keydown", onKey, true);
+    document.removeEventListener("focusin", onFocus, true);
+    window.removeEventListener("resize", hide);
+    document.removeEventListener("scroll", hide, true);
+    hide();
+    markTargets();
+  }
+}
+
+export function initHelpMode() {
+  const btn = document.getElementById("helpModeBtn");
+  if (!btn || btn.dataset.ready === "1") return;
+  btn.dataset.ready = "1";
+  tipEl = document.createElement("div");
+  tipEl.className = "help-tip";
+  tipEl.id = "helpTip";
+  tipEl.setAttribute("role", "tooltip");
+  tipEl.hidden = true;
+  pillEl = document.createElement("div");
+  pillEl.className = "help-pill";
+  pillEl.setAttribute("role", "status");
+  pillEl.hidden = true;
+  ringEl = document.createElement("div");
+  ringEl.className = "help-ring";
+  ringEl.setAttribute("aria-hidden", "true");
+  ringEl.hidden = true;
+  document.body.append(ringEl, tipEl, pillEl);
+  btn.addEventListener("click", () => setHelpMode(!on));
+}
diff --git a/static/js/i18n.js b/static/js/i18n.js
index 174f2289..d6e9f29b 100644
--- a/static/js/i18n.js
+++ b/static/js/i18n.js
@@ -434,6 +434,7 @@ const en = {
   "nav.library": "Library",
   "nav.favorites": "Favorites",
   "nav.trash": "Trash",
+  "nav.trashWithCount": "Trash ({count})",
   "nav.importQueue": "Import queue",
   "nav.queue": "Queue",
   "nav.settings": "Settings",
@@ -441,6 +442,84 @@ const en = {
   "nav.weRecommendLine1": "We",
   "nav.weRecommendLine2": "Recommend",
   "nav.help": "Help",
+  "help.button": "Explain the screen",
+  "help.railLabel": "Guide",
+  "help.pill": "Help mode: point at anything to see what it does. Esc to leave.",
+  "help.helpMode": "Help mode is on. Point at anything, or click it, to see what it does. Press Esc or this button to leave.",
+  "help.website": "Opens stemdeck.app in your browser.",
+  "help.upload": "Pick an audio file from your computer to split into its instruments.",
+  "help.search": "Type a song name to search for it online, or paste a link. You can also drop an audio file here.",
+  "help.stemAll": "Extract every instrument the song has.",
+  "help.stemChip": "Click to include or leave out {name} when you extract.",
+  "help.vocalCombined": "Keeps all the singing in one Vocals lane.",
+  "help.vocalSplit": "Splits the singing into the lead voice and the backing voices.",
+  "help.detectStructure": "Experimental. When on, the next song you import gets its intro, verse and chorus marked for you.",
+  "help.analysisToggle": "Shows or hides the row of song facts: key, tempo, loudness and more.",
+  "help.sectionsToggle": "Shows or hides the sections bar, where the parts of the song are marked.",
+  "help.extract": "Starts splitting the song into its instruments. Each one gets its own lane below.",
+  "help.favorite": "Adds the open song to Favorites, or takes it out.",
+  "help.songDetails": "Details about the open song.",
+  "help.toggleLibrary": "Hides the song list to give the studio more room, or brings it back.",
+  "help.favorites": "Shows only the songs you gave a heart.",
+  "help.library": "Shows all your songs in the list.",
+  "help.lyrics": "Shows the words of the song, lit up line by line as it plays.",
+  "help.trash": "Deleted songs wait here until you empty the Trash. The number shows how many there are.",
+  "help.queue": "The songs waiting to be split, in the order they will be done.",
+  "help.notifications": "Messages from StemDeck, such as a new release or an import that failed.",
+  "help.recommend": "Artists, instrument makers and gear worth knowing. StemDeck takes no money from any of them.",
+  "help.about": "Links to the website, GitHub and Discord, and the credits.",
+  "help.searchLibrary": "Type part of a song's name to find it. Start with # to find songs by tag.",
+  "help.newFolder": "Makes a folder, so you can sort your songs.",
+  "help.trashedSong": "A deleted song. Hold it for a second to bring it back.",
+  "help.song": "Click a song to open it in the studio.",
+  "help.addSection": "Adds a section, like a verse or a chorus, to the sections bar.",
+  "help.volume": "Drag to make {name} louder or quieter.",
+  "help.laneKeyUp": "Moves only {name} up one semitone, the smallest step in music.",
+  "help.laneKeyDown": "Moves only {name} down one semitone, the smallest step in music.",
+  "help.laneKeyTitle": "Key of {name}",
+  "help.laneKey": "The key of {name}. K means its original key; a number means how many semitones it moved.",
+  "help.mute": "Silences {name}, so you can play or sing that part yourself.",
+  "help.solo": "Plays only {name}, to hear it clearly.",
+  "help.download": "Saves {name} as its own audio file.",
+  "help.songFactsTitle": "Song facts",
+  "help.songFacts": "Found for you: the key, the tempo in BPM, loudness, length and how much of each instrument the song has.",
+  "help.wavesTitle": "Waveforms",
+  "help.waves": "Each instrument's sound, drawn over time. Click to jump to that moment. Drag across to loop that part.",
+  "help.stop": "Stops the song.",
+  "help.play": "Plays the song, or pauses it.",
+  "help.loop": "Turns looping on or off: the part between the two times beside it repeats. The L key does the same.",
+  "help.loopStart": "Where the loop begins, in seconds. Scroll over it to move it.",
+  "help.loopEnd": "Where the loop ends, in seconds. Scroll over it to move it.",
+  "help.speedHalf": "Plays at half speed. The pitch stays the same.",
+  "help.speedSlow": "Plays at three-quarter speed. Scroll over it to pick any speed from 0.50x to 0.99x.",
+  "help.speedNormal": "Plays at the song's own speed.",
+  "help.keyDown": "Moves the whole song down one semitone, the smallest step in music.",
+  "help.keyUp": "Moves the whole song up one semitone, the smallest step in music.",
+  "help.keyReset": "Puts every part back in the song's original key.",
+  "help.click": "Turns on a click that follows the song's tempo. The K key does the same.",
+  "help.clickVolume": "How loud the click is.",
+  "help.clickMore": "More settings for the click track.",
+  "help.export": "Saves what you hear as one audio file. Its menu also offers every part as a .zip, or only the looped part.",
+  "help.set.language": "The language of the app.",
+  "help.set.maxDuration": "The longest song it accepts, in minutes.",
+  "help.set.playlistLimit": "The most songs one playlist adds.",
+  "help.set.cookies": "Only needed if YouTube asks you to prove you are not a bot.",
+  "help.set.stemsLocation": "Where your separated songs are stored.",
+  "help.set.exportsLocation": "Where stems and loops you drag out of StemDeck go.",
+  "help.set.autoDelete": "Off unless you turn it on. Deletes songs after the number of days you set.",
+  "help.set.device": "Your graphics card or your processor, for separating.",
+  "help.set.quality": "Best gives cleaner stems and takes twice as long.",
+  "help.set.exportLogs": "Every log in one zip, to attach to a bug report.",
+  "help.set.resetData": "Deletes every song. It cannot be undone.",
+  "help.set.acoustid": "Recognises each song by its sound, with a free AcoustID key.",
+  "help.set.discogs": "Band profiles and releases, with a free Discogs token.",
+  "help.set.transcribe": "Writes down the words from the vocals when no lyrics are found.",
+  "help.set.network": "Open StemDeck on your phone or tablet, on the same Wi-Fi. Scan the QR code, or type the address shown.",
+  "help.set.port": "The port StemDeck runs on. Restart to apply.",
+  "help.set.sampleRate": "The sample rate of the audio files you export.",
+  "help.set.videoQuality": "The quality of the videos you export.",
+  "help.set.logs": "Where the logs are, and the application, backend and setup logs.",
+  "help.set.registry": "The list of finished songs StemDeck keeps on disk. Read only.",
 
   "search.ariaLabel": "Search library",
   "search.placeholder": "Search or #tag…",
@@ -464,6 +543,7 @@ const en = {
   "trash.empty": "Empty trash",
   "trash.isEmptyState": "Trash is empty",
   "trash.noSearchMatch": "No deleted tracks match your search",
+  "trash.holdToRestore": "Hold left click for 1 second to restore",
 
   "meta.key": "Key",
   "key.label": "{tonic} {mode}",
@@ -805,6 +885,9 @@ const en = {
   "track.untitled": "Untitled track",
   "track.unknown": "Unknown track",
   "track.removed": "Removed",
+  "track.stopped": "Stopped",
+  "track.extractAgain": "Extract",
+  "track.extractAgainOf": "Extract {title} again",
   "track.moveToTrash": "Move to Trash",
   "track.moveTitleToTrash": "Move {title} to Trash",
   "track.favorite": "Add to Favorites",
@@ -1241,6 +1324,7 @@ const pl = {
   "nav.library": "Biblioteka",
   "nav.favorites": "Ulubione",
   "nav.trash": "Kosz",
+  "nav.trashWithCount": "Kosz ({count})",
   "nav.importQueue": "Kolejka importu",
   "nav.queue": "Kolejka",
   "nav.settings": "Ustawienia",
@@ -1248,6 +1332,84 @@ const pl = {
   "nav.weRecommendLine1": "Pole-",
   "nav.weRecommendLine2": "camy",
   "nav.help": "Pomoc",
+  "help.button": "Wyjaśnij ekran",
+  "help.railLabel": "Przewodnik",
+  "help.pill": "Tryb pomocy: wskaż dowolny element, aby zobaczyć, co robi. Esc, aby wyjść.",
+  "help.helpMode": "Tryb pomocy jest włączony. Wskaż lub kliknij dowolny element, aby zobaczyć, co robi. Esc lub ten przycisk go wyłącza.",
+  "help.website": "Otwiera stemdeck.app w przeglądarce.",
+  "help.upload": "Wybierz plik audio z komputera, aby rozdzielić go na instrumenty.",
+  "help.search": "Wpisz nazwę utworu, aby wyszukać go w sieci, lub wklej link. Możesz też upuścić tu plik audio.",
+  "help.stemAll": "Wyodrębnia każdy instrument w utworze.",
+  "help.stemChip": "Kliknij, aby uwzględnić lub pominąć {name} przy wyodrębnianiu.",
+  "help.vocalCombined": "Zostawia cały śpiew na jednej ścieżce wokalu.",
+  "help.vocalSplit": "Dzieli śpiew na wokal główny i chórki.",
+  "help.detectStructure": "Eksperymentalne. Gdy włączone, następny importowany utwór dostanie oznaczone intro, zwrotki i refreny.",
+  "help.analysisToggle": "Pokazuje lub ukrywa wiersz danych utworu: tonację, tempo, głośność i więcej.",
+  "help.sectionsToggle": "Pokazuje lub ukrywa pasek sekcji, na którym oznaczone są części utworu.",
+  "help.extract": "Zaczyna rozdzielać utwór na instrumenty. Każdy dostaje własną ścieżkę poniżej.",
+  "help.favorite": "Dodaje otwarty utwór do Ulubionych albo go z nich usuwa.",
+  "help.songDetails": "Szczegóły otwartego utworu.",
+  "help.toggleLibrary": "Ukrywa listę utworów, by dać studiu więcej miejsca, albo ją przywraca.",
+  "help.favorites": "Pokazuje tylko utwory, którym dałeś serce.",
+  "help.library": "Pokazuje wszystkie twoje utwory na liście.",
+  "help.lyrics": "Pokazuje tekst utworu, podświetlany linijka po linijce podczas odtwarzania.",
+  "help.trash": "Usunięte utwory czekają tu, aż opróżnisz kosz. Liczba pokazuje, ile ich jest.",
+  "help.queue": "Utwory czekające na rozdzielenie, w kolejności, w jakiej zostaną przetworzone.",
+  "help.notifications": "Wiadomości od StemDeck, na przykład o nowej wersji albo nieudanym imporcie.",
+  "help.recommend": "Artyści, lutnicy i sprzęt warte poznania. StemDeck nie bierze pieniędzy od nikogo z nich.",
+  "help.about": "Linki do strony, GitHuba i Discorda oraz podziękowania.",
+  "help.searchLibrary": "Wpisz część nazwy utworu, aby go znaleźć. Zacznij od #, aby szukać po tagu.",
+  "help.newFolder": "Tworzy folder, w którym możesz porządkować utwory.",
+  "help.trashedSong": "Usunięty utwór. Przytrzymaj go przez sekundę, aby go przywrócić.",
+  "help.song": "Kliknij utwór, aby otworzyć go w studiu.",
+  "help.addSection": "Dodaje sekcję, na przykład zwrotkę lub refren, do paska sekcji.",
+  "help.volume": "Przeciągnij, aby {name} grało głośniej lub ciszej.",
+  "help.laneKeyUp": "Podnosi tylko {name} o półton, najmniejszy krok w muzyce.",
+  "help.laneKeyDown": "Obniża tylko {name} o półton, najmniejszy krok w muzyce.",
+  "help.laneKeyTitle": "Tonacja: {name}",
+  "help.laneKey": "Tonacja: {name}. K oznacza oryginalną tonację; liczba pokazuje, o ile półtonów ją przesunięto.",
+  "help.mute": "Wycisza {name}, żebyś mógł sam zagrać lub zaśpiewać tę partię.",
+  "help.solo": "Odtwarza tylko {name}, żeby było wyraźnie słychać.",
+  "help.download": "Zapisuje {name} jako osobny plik audio.",
+  "help.songFactsTitle": "Dane utworu",
+  "help.songFacts": "Wyznaczone dla ciebie: tonacja, tempo w BPM, głośność, długość i udział każdego instrumentu.",
+  "help.wavesTitle": "Przebiegi",
+  "help.waves": "Dźwięk każdego instrumentu w czasie. Kliknij, aby przejść do tego momentu. Przeciągnij, aby zapętlić ten fragment.",
+  "help.stop": "Zatrzymuje utwór.",
+  "help.play": "Odtwarza utwór albo go wstrzymuje.",
+  "help.loop": "Włącza lub wyłącza pętlę: fragment między dwoma czasami obok się powtarza. Klawisz L robi to samo.",
+  "help.loopStart": "Gdzie zaczyna się pętla, w sekundach. Przewiń nad nim kółkiem, aby ją przesunąć.",
+  "help.loopEnd": "Gdzie kończy się pętla, w sekundach. Przewiń nad nim kółkiem, aby ją przesunąć.",
+  "help.speedHalf": "Odtwarza w połowie prędkości. Wysokość dźwięku się nie zmienia.",
+  "help.speedSlow": "Odtwarza w trzech czwartych prędkości. Przewiń nad nim kółkiem, aby wybrać prędkość od 0.50x do 0.99x.",
+  "help.speedNormal": "Odtwarza w oryginalnej prędkości utworu.",
+  "help.keyDown": "Obniża cały utwór o półton, najmniejszy krok w muzyce.",
+  "help.keyUp": "Podnosi cały utwór o półton, najmniejszy krok w muzyce.",
+  "help.keyReset": "Przywraca każdą partię do oryginalnej tonacji utworu.",
+  "help.click": "Włącza klik, który podąża za tempem utworu. Klawisz K robi to samo.",
+  "help.clickVolume": "Jak głośny jest klik.",
+  "help.clickMore": "Więcej ustawień kliku.",
+  "help.export": "Zapisuje to, co słyszysz, jako jeden plik audio. Jego menu oferuje też każdą partię w .zip albo tylko zapętlony fragment.",
+  "help.set.language": "Język aplikacji.",
+  "help.set.maxDuration": "Najdłuższy przyjmowany utwór, w minutach.",
+  "help.set.playlistLimit": "Najwięcej utworów, jakie doda jedna playlista.",
+  "help.set.cookies": "Potrzebne tylko, gdy YouTube poprosi o potwierdzenie, że nie jesteś botem.",
+  "help.set.stemsLocation": "Gdzie zapisywane są rozdzielone utwory.",
+  "help.set.exportsLocation": "Dokąd trafiają ścieżki i pętle przeciągnięte poza StemDeck.",
+  "help.set.autoDelete": "Wyłączone, dopóki tego nie włączysz. Usuwa utwory po wybranej liczbie dni.",
+  "help.set.device": "Twoja karta graficzna lub procesor, do rozdzielania.",
+  "help.set.quality": "Best daje czystsze ścieżki i trwa dwa razy dłużej.",
+  "help.set.exportLogs": "Wszystkie logi w jednym zipie, do zgłoszenia błędu.",
+  "help.set.resetData": "Usuwa wszystkie utwory. Nie można tego cofnąć.",
+  "help.set.acoustid": "Rozpoznaje każdy utwór po brzmieniu, z darmowym kluczem AcoustID.",
+  "help.set.discogs": "Profile zespołów i wydania, z darmowym tokenem Discogs.",
+  "help.set.transcribe": "Spisuje tekst z wokalu, gdy nie znaleziono tekstu utworu.",
+  "help.set.network": "Otwórz StemDeck na telefonie lub tablecie w tej samej sieci Wi-Fi. Zeskanuj kod QR lub wpisz pokazany adres.",
+  "help.set.port": "Port, na którym działa StemDeck. Uruchom ponownie, aby zastosować.",
+  "help.set.sampleRate": "Częstotliwość próbkowania eksportowanych plików audio.",
+  "help.set.videoQuality": "Jakość eksportowanych filmów.",
+  "help.set.logs": "Gdzie są logi oraz logi aplikacji, serwera i instalacji.",
+  "help.set.registry": "Lista ukończonych utworów, którą StemDeck trzyma na dysku. Tylko do odczytu.",
 
   "search.ariaLabel": "Szukaj w bibliotece",
   "search.placeholder": "Szukaj lub #tag…",
@@ -1271,6 +1433,7 @@ const pl = {
   "trash.empty": "Opróżnij kosz",
   "trash.isEmptyState": "Kosz jest pusty",
   "trash.noSearchMatch": "Żadne usunięte utwory nie pasują do wyszukiwania",
+  "trash.holdToRestore": "Przytrzymaj lewy przycisk przez 1 sekundę, aby przywrócić",
 
   "meta.key": "Tonacja",
   "key.label": "{tonic} {mode}",
@@ -1614,6 +1777,9 @@ const pl = {
   "track.untitled": "Utwór bez tytułu",
   "track.unknown": "Nieznany utwór",
   "track.removed": "Usunięto",
+  "track.stopped": "Zatrzymano",
+  "track.extractAgain": "Wyodrębnij",
+  "track.extractAgainOf": "Wyodrębnij ponownie {title}",
   "track.moveToTrash": "Przenieś do kosza",
   "track.moveTitleToTrash": "Przenieś {title} do kosza",
   "track.favorite": "Dodaj do ulubionych",
@@ -2038,6 +2204,7 @@ const ja = {
   "nav.library": "ライブラリ",
   "nav.favorites": "お気に入り",
   "nav.trash": "ゴミ箱",
+  "nav.trashWithCount": "ゴミ箱 ({count})",
   "nav.importQueue": "インポートキュー",
   "nav.queue": "キュー",
   "nav.settings": "設定",
@@ -2045,6 +2212,84 @@ const ja = {
   "nav.weRecommendLine1": "おす",
   "nav.weRecommendLine2": "すめ",
   "nav.help": "ヘルプ",
+  "help.button": "画面を説明",
+  "help.railLabel": "ガイド",
+  "help.pill": "ヘルプモード：項目を指すと、その働きが表示されます。Esc で終了。",
+  "help.helpMode": "ヘルプモードがオンです。項目を指すかクリックすると、その働きが表示されます。Esc かこのボタンで終了します。",
+  "help.website": "ブラウザで stemdeck.app を開きます。",
+  "help.upload": "パソコンから音声ファイルを選び、楽器ごとに分けます。",
+  "help.search": "曲名を入力してオンラインで検索するか、リンクを貼り付けます。音声ファイルをここにドロップすることもできます。",
+  "help.stemAll": "曲に含まれるすべての楽器を抽出します。",
+  "help.stemChip": "クリックすると、抽出に{name}を含めるか外すかを切り替えます。",
+  "help.vocalCombined": "歌声をすべて 1 つのボーカルレーンにまとめます。",
+  "help.vocalSplit": "歌声をリードボーカルとバックボーカルに分けます。",
+  "help.detectStructure": "実験的機能。オンにすると、次に取り込む曲のイントロ、Aメロ、サビに印が付きます。",
+  "help.analysisToggle": "キー、テンポ、ラウドネスなど、曲の情報の行を表示または非表示にします。",
+  "help.sectionsToggle": "曲のパートが示されるセクションバーを表示または非表示にします。",
+  "help.extract": "曲を楽器ごとに分け始めます。それぞれ下に専用のレーンができます。",
+  "help.favorite": "開いている曲をお気に入りに追加するか、外します。",
+  "help.songDetails": "開いている曲の詳細です。",
+  "help.toggleLibrary": "曲リストを隠してスタジオを広くするか、元に戻します。",
+  "help.favorites": "ハートを付けた曲だけを表示します。",
+  "help.library": "すべての曲をリストに表示します。",
+  "help.lyrics": "曲の歌詞を表示し、再生に合わせて 1 行ずつ光ります。",
+  "help.trash": "削除した曲は、ゴミ箱を空にするまでここに残ります。数字は曲の数です。",
+  "help.queue": "分離を待っている曲を、処理される順に並べています。",
+  "help.notifications": "新しいリリースや失敗した取り込みなど、StemDeck からのお知らせです。",
+  "help.recommend": "知っておきたいアーティスト、楽器職人、機材です。StemDeck はどこからもお金を受け取っていません。",
+  "help.about": "ウェブサイト、GitHub、Discord へのリンクとクレジットです。",
+  "help.searchLibrary": "曲名の一部を入力して探します。# から始めるとタグで探せます。",
+  "help.newFolder": "曲を整理するためのフォルダーを作ります。",
+  "help.trashedSong": "削除した曲です。1 秒長押しすると元に戻ります。",
+  "help.song": "曲をクリックするとスタジオで開きます。",
+  "help.addSection": "Aメロやサビなどのセクションをセクションバーに追加します。",
+  "help.volume": "ドラッグして{name}の音量を上げ下げします。",
+  "help.laneKeyUp": "{name}だけを半音上げます。半音は音楽で最も小さな音程の単位です。",
+  "help.laneKeyDown": "{name}だけを半音下げます。半音は音楽で最も小さな音程の単位です。",
+  "help.laneKeyTitle": "{name}のキー",
+  "help.laneKey": "{name}のキーです。K は元のキー、数字は何半音動かしたかを示します。",
+  "help.mute": "{name}をミュートします。そのパートを自分で演奏したり歌ったりできます。",
+  "help.solo": "{name}だけを再生して、はっきり聞けるようにします。",
+  "help.download": "{name}を単独の音声ファイルとして保存します。",
+  "help.songFactsTitle": "曲の情報",
+  "help.songFacts": "キー、BPM で表したテンポ、ラウドネス、長さ、各楽器の割合を自動で調べています。",
+  "help.wavesTitle": "波形",
+  "help.waves": "各楽器の音を時間に沿って描いたものです。クリックでその位置へ移動し、ドラッグでその部分をループします。",
+  "help.stop": "曲を止めます。",
+  "help.play": "曲を再生、または一時停止します。",
+  "help.loop": "ループのオンとオフを切り替えます。横の 2 つの時間の間が繰り返されます。L キーでも同じです。",
+  "help.loopStart": "ループの開始位置(秒)です。上でスクロールすると動かせます。",
+  "help.loopEnd": "ループの終了位置(秒)です。上でスクロールすると動かせます。",
+  "help.speedHalf": "半分の速さで再生します。音の高さは変わりません。",
+  "help.speedSlow": "4 分の 3 の速さで再生します。上でスクロールすると 0.50x から 0.99x の間で選べます。",
+  "help.speedNormal": "曲本来の速さで再生します。",
+  "help.keyDown": "曲全体を半音下げます。半音は音楽で最も小さな音程の単位です。",
+  "help.keyUp": "曲全体を半音上げます。半音は音楽で最も小さな音程の単位です。",
+  "help.keyReset": "すべてのパートを曲の元のキーに戻します。",
+  "help.click": "曲のテンポに合わせたクリックをオンにします。K キーでも同じです。",
+  "help.clickVolume": "クリックの音量です。",
+  "help.clickMore": "クリックのその他の設定です。",
+  "help.export": "聞こえている音を 1 つの音声ファイルとして保存します。メニューから、全パートの .zip やループ部分だけも選べます。",
+  "help.set.language": "アプリの表示言語です。",
+  "help.set.maxDuration": "受け付ける曲の最大の長さ(分)です。",
+  "help.set.playlistLimit": "1 つのプレイリストで追加される曲の最大数です。",
+  "help.set.cookies": "YouTube にボットでないことの確認を求められたときだけ必要です。",
+  "help.set.stemsLocation": "分離した曲の保存場所です。",
+  "help.set.exportsLocation": "StemDeck からドラッグしたステムやループの保存先です。",
+  "help.set.autoDelete": "オンにしない限りオフです。指定した日数が過ぎた曲を削除します。",
+  "help.set.device": "分離に使うグラフィックカードまたはプロセッサーです。",
+  "help.set.quality": "Best はステムがよりきれいになり、時間が 2 倍かかります。",
+  "help.set.exportLogs": "すべてのログを 1 つの zip にまとめます。不具合の報告に添付できます。",
+  "help.set.resetData": "すべての曲を削除します。元に戻せません。",
+  "help.set.acoustid": "無料の AcoustID キーで、音から各曲を識別します。",
+  "help.set.discogs": "無料の Discogs トークンで、バンドのプロフィールとリリースを取得します。",
+  "help.set.transcribe": "歌詞が見つからないとき、ボーカルから歌詞を書き起こします。",
+  "help.set.network": "同じ Wi-Fi のスマートフォンやタブレットで StemDeck を開けます。QR コードを読み取るか、表示されたアドレスを入力します。",
+  "help.set.port": "StemDeck が動くポートです。再起動すると反映されます。",
+  "help.set.sampleRate": "書き出す音声ファイルのサンプルレートです。",
+  "help.set.videoQuality": "書き出す動画の画質です。",
+  "help.set.logs": "ログの保存場所と、アプリ、バックエンド、セットアップのログです。",
+  "help.set.registry": "StemDeck がディスクに保存している完了した曲の一覧です。読み取り専用です。",
 
   "search.ariaLabel": "ライブラリを検索",
   "search.placeholder": "検索または#タグ…",
@@ -2068,6 +2313,7 @@ const ja = {
   "trash.empty": "ゴミ箱を空にする",
   "trash.isEmptyState": "ゴミ箱は空です",
   "trash.noSearchMatch": "検索に一致する削除済みトラックはありません",
+  "trash.holdToRestore": "左クリックを1秒長押しで復元",
 
   "meta.key": "キー",
   "key.label": "{tonic} {mode}",
@@ -2402,6 +2648,9 @@ const ja = {
   "track.untitled": "無題のトラック",
   "track.unknown": "不明なトラック",
   "track.removed": "削除済み",
+  "track.stopped": "停止済み",
+  "track.extractAgain": "抽出",
+  "track.extractAgainOf": "{title} を再抽出",
   "track.moveToTrash": "ゴミ箱に移動",
   "track.moveTitleToTrash": "{title}をゴミ箱に移動",
   "track.favorite": "お気に入りに追加",
@@ -2810,6 +3059,7 @@ const zhHans = {
   "nav.library": "资料库",
   "nav.favorites": "收藏夹",
   "nav.trash": "回收站",
+  "nav.trashWithCount": "回收站 ({count})",
   "nav.importQueue": "导入队列",
   "nav.queue": "队列",
   "nav.settings": "设置",
@@ -2817,6 +3067,84 @@ const zhHans = {
   "nav.weRecommendLine1": "推",
   "nav.weRecommendLine2": "荐",
   "nav.help": "帮助",
+  "help.button": "讲解界面",
+  "help.railLabel": "指南",
+  "help.pill": "帮助模式：指向任何项目即可看到它的作用。按 Esc 退出。",
+  "help.helpMode": "帮助模式已开启。指向或点击任何项目即可看到它的作用。按 Esc 或此按钮退出。",
+  "help.website": "在浏览器中打开 stemdeck.app。",
+  "help.upload": "从电脑中选择一个音频文件，把它分离成各个乐器。",
+  "help.search": "输入歌名在线搜索，或粘贴链接。也可以把音频文件拖到这里。",
+  "help.stemAll": "提取歌曲中的所有乐器。",
+  "help.stemChip": "点击以在提取时包含或排除{name}。",
+  "help.vocalCombined": "把所有歌声保留在一条人声音轨中。",
+  "help.vocalSplit": "把歌声分成主唱和和声。",
+  "help.detectStructure": "实验功能。开启后，下一首导入的歌曲会自动标出前奏、主歌和副歌。",
+  "help.analysisToggle": "显示或隐藏歌曲信息行：调性、速度、响度等。",
+  "help.sectionsToggle": "显示或隐藏段落栏，歌曲的各个部分在那里标出。",
+  "help.extract": "开始把歌曲分离成各个乐器。每个乐器在下方有自己的音轨。",
+  "help.favorite": "把当前歌曲加入收藏，或移出收藏。",
+  "help.songDetails": "当前歌曲的详细信息。",
+  "help.toggleLibrary": "隐藏歌曲列表让工作室更宽敞，或重新显示。",
+  "help.favorites": "只显示你点了心的歌曲。",
+  "help.library": "在列表中显示你的所有歌曲。",
+  "help.lyrics": "显示歌词，播放时逐行点亮。",
+  "help.trash": "删除的歌曲会留在这里，直到你清空回收站。数字表示有多少首。",
+  "help.queue": "等待分离的歌曲，按处理顺序排列。",
+  "help.notifications": "来自 StemDeck 的消息，例如新版本或导入失败。",
+  "help.recommend": "值得认识的艺术家、乐器制作者和设备。StemDeck 不接受其中任何一方的钱。",
+  "help.about": "网站、GitHub 和 Discord 的链接，以及致谢。",
+  "help.searchLibrary": "输入歌名的一部分来查找。以 # 开头可按标签查找。",
+  "help.newFolder": "新建文件夹，用来整理歌曲。",
+  "help.trashedSong": "已删除的歌曲。按住一秒即可恢复。",
+  "help.song": "点击歌曲，在工作室中打开它。",
+  "help.addSection": "在段落栏中添加一个段落，例如主歌或副歌。",
+  "help.volume": "拖动以调大或调小{name}的音量。",
+  "help.laneKeyUp": "只把{name}升高一个半音，半音是音乐中最小的音程。",
+  "help.laneKeyDown": "只把{name}降低一个半音，半音是音乐中最小的音程。",
+  "help.laneKeyTitle": "{name}的调",
+  "help.laneKey": "{name}的调。K 表示原调；数字表示移动了几个半音。",
+  "help.mute": "将{name}静音，让你自己演奏或演唱这一部分。",
+  "help.solo": "只播放{name}，听得更清楚。",
+  "help.download": "把{name}保存为单独的音频文件。",
+  "help.songFactsTitle": "歌曲信息",
+  "help.songFacts": "已为你分析：调性、以 BPM 表示的速度、响度、时长，以及每种乐器的占比。",
+  "help.wavesTitle": "波形",
+  "help.waves": "每种乐器的声音随时间的变化。点击跳到那一刻，拖动可循环那一段。",
+  "help.stop": "停止播放。",
+  "help.play": "播放歌曲，或暂停。",
+  "help.loop": "开启或关闭循环：旁边两个时间之间的部分会重复。按 L 键效果相同。",
+  "help.loopStart": "循环的开始位置，单位为秒。在上面滚动即可移动。",
+  "help.loopEnd": "循环的结束位置，单位为秒。在上面滚动即可移动。",
+  "help.speedHalf": "以一半速度播放，音高不变。",
+  "help.speedSlow": "以四分之三速度播放。在上面滚动可选择 0.50x 到 0.99x 之间的任意速度。",
+  "help.speedNormal": "以歌曲原速播放。",
+  "help.keyDown": "把整首歌降低一个半音，半音是音乐中最小的音程。",
+  "help.keyUp": "把整首歌升高一个半音，半音是音乐中最小的音程。",
+  "help.keyReset": "把每一部分恢复到歌曲的原调。",
+  "help.click": "开启跟随歌曲速度的节拍声。按 K 键效果相同。",
+  "help.clickVolume": "节拍声的音量。",
+  "help.clickMore": "节拍声的更多设置。",
+  "help.export": "把你听到的内容保存为一个音频文件。菜单中还可以把每个部分打包为 .zip，或只导出循环部分。",
+  "help.set.language": "应用的显示语言。",
+  "help.set.maxDuration": "可接受的最长歌曲，单位为分钟。",
+  "help.set.playlistLimit": "一个播放列表最多添加的歌曲数。",
+  "help.set.cookies": "只有在 YouTube 要求你证明自己不是机器人时才需要。",
+  "help.set.stemsLocation": "分离后歌曲的存放位置。",
+  "help.set.exportsLocation": "从 StemDeck 拖出的音轨和循环的存放位置。",
+  "help.set.autoDelete": "默认关闭。开启后会在你设定的天数后删除歌曲。",
+  "help.set.device": "用于分离的显卡或处理器。",
+  "help.set.quality": "Best 的分离更干净，耗时是两倍。",
+  "help.set.exportLogs": "把所有日志打包成一个 zip，可附在错误报告中。",
+  "help.set.resetData": "删除所有歌曲，无法撤销。",
+  "help.set.acoustid": "使用免费的 AcoustID 密钥，按声音识别每首歌曲。",
+  "help.set.discogs": "使用免费的 Discogs 令牌，获取乐队资料和发行信息。",
+  "help.set.transcribe": "找不到歌词时，从人声中转写歌词。",
+  "help.set.network": "在同一 Wi-Fi 下用手机或平板打开 StemDeck。扫描二维码，或输入显示的地址。",
+  "help.set.port": "StemDeck 运行的端口。重启后生效。",
+  "help.set.sampleRate": "导出音频文件的采样率。",
+  "help.set.videoQuality": "导出视频的画质。",
+  "help.set.logs": "日志的位置，以及应用、后端和安装日志。",
+  "help.set.registry": "StemDeck 保存在磁盘上的已完成歌曲列表。只读。",
 
   "search.ariaLabel": "搜索资料库",
   "search.placeholder": "搜索或 #标签…",
@@ -2840,6 +3168,7 @@ const zhHans = {
   "trash.empty": "清空回收站",
   "trash.isEmptyState": "回收站是空的",
   "trash.noSearchMatch": "没有已删除的曲目与你的搜索匹配",
+  "trash.holdToRestore": "按住鼠标左键 1 秒即可恢复",
 
   "meta.key": "调性",
   "key.label": "{tonic} {mode}",
@@ -3174,6 +3503,9 @@ const zhHans = {
   "track.untitled": "未命名曲目",
   "track.unknown": "未知曲目",
   "track.removed": "已移除",
+  "track.stopped": "已停止",
+  "track.extractAgain": "提取",
+  "track.extractAgainOf": "重新提取 {title}",
   "track.moveToTrash": "移到回收站",
   "track.moveTitleToTrash": "将 {title} 移到回收站",
   "track.favorite": "添加到收藏",
@@ -3582,6 +3914,7 @@ const de = {
   "nav.library": "Bibliothek",
   "nav.favorites": "Favoriten",
   "nav.trash": "Papierkorb",
+  "nav.trashWithCount": "Papierkorb ({count})",
   "nav.importQueue": "Importwarteschlange",
   "nav.queue": "Warteschlange",
   "nav.settings": "Einstellungen",
@@ -3589,6 +3922,84 @@ const de = {
   "nav.weRecommendLine1": "Wir",
   "nav.weRecommendLine2": "empfehlen",
   "nav.help": "Hilfe",
+  "help.button": "Bildschirm erklären",
+  "help.railLabel": "Anleitung",
+  "help.pill": "Hilfemodus: Zeig auf etwas, um zu sehen, was es tut. Esc zum Beenden.",
+  "help.helpMode": "Der Hilfemodus ist an. Zeig auf etwas oder klick es an, um zu sehen, was es tut. Esc oder dieser Button beendet ihn.",
+  "help.website": "Öffnet stemdeck.app in deinem Browser.",
+  "help.upload": "Wähle eine Audiodatei auf deinem Computer, um sie in ihre Instrumente zu zerlegen.",
+  "help.search": "Gib einen Songnamen ein, um online danach zu suchen, oder füge einen Link ein. Du kannst auch eine Audiodatei hierher ziehen.",
+  "help.stemAll": "Extrahiert jedes Instrument, das der Song hat.",
+  "help.stemChip": "Klick, um {name} beim Extrahieren mitzunehmen oder wegzulassen.",
+  "help.vocalCombined": "Behält den ganzen Gesang in einer Vocals-Spur.",
+  "help.vocalSplit": "Teilt den Gesang in Leadstimme und Begleitstimmen.",
+  "help.detectStructure": "Experimentell. Wenn an, bekommt der nächste importierte Song Intro, Strophe und Refrain markiert.",
+  "help.analysisToggle": "Zeigt oder versteckt die Zeile mit den Songdaten: Tonart, Tempo, Lautheit und mehr.",
+  "help.sectionsToggle": "Zeigt oder versteckt die Abschnittsleiste, in der die Teile des Songs markiert sind.",
+  "help.extract": "Startet das Zerlegen des Songs in seine Instrumente. Jedes bekommt unten eine eigene Spur.",
+  "help.favorite": "Fügt den offenen Song zu den Favoriten hinzu oder nimmt ihn wieder heraus.",
+  "help.songDetails": "Details zum offenen Song.",
+  "help.toggleLibrary": "Blendet die Songliste aus, damit das Studio mehr Platz hat, oder holt sie zurück.",
+  "help.favorites": "Zeigt nur die Songs, denen du ein Herz gegeben hast.",
+  "help.library": "Zeigt alle deine Songs in der Liste.",
+  "help.lyrics": "Zeigt den Songtext, Zeile für Zeile hervorgehoben, während der Song läuft.",
+  "help.trash": "Gelöschte Songs warten hier, bis du den Papierkorb leerst. Die Zahl zeigt, wie viele es sind.",
+  "help.queue": "Die Songs, die auf das Zerlegen warten, in der Reihenfolge, in der sie drankommen.",
+  "help.notifications": "Nachrichten von StemDeck, etwa eine neue Version oder ein fehlgeschlagener Import.",
+  "help.recommend": "Künstler, Instrumentenbauer und Equipment, die man kennen sollte. StemDeck nimmt von keinem davon Geld.",
+  "help.about": "Links zur Website, zu GitHub und Discord, und die Credits.",
+  "help.searchLibrary": "Gib einen Teil des Songnamens ein, um ihn zu finden. Beginne mit #, um nach Tag zu suchen.",
+  "help.newFolder": "Legt einen Ordner an, damit du deine Songs sortieren kannst.",
+  "help.trashedSong": "Ein gelöschter Song. Halte ihn eine Sekunde lang gedrückt, um ihn zurückzuholen.",
+  "help.song": "Klick auf einen Song, um ihn im Studio zu öffnen.",
+  "help.addSection": "Fügt der Abschnittsleiste einen Abschnitt hinzu, etwa eine Strophe oder einen Refrain.",
+  "help.volume": "Zieh, um {name} lauter oder leiser zu machen.",
+  "help.laneKeyUp": "Hebt nur {name} um einen Halbton an, den kleinsten Schritt in der Musik.",
+  "help.laneKeyDown": "Senkt nur {name} um einen Halbton, den kleinsten Schritt in der Musik.",
+  "help.laneKeyTitle": "Tonart von {name}",
+  "help.laneKey": "Die Tonart von {name}. K heißt Originaltonart; eine Zahl zeigt, um wie viele Halbtöne verschoben wurde.",
+  "help.mute": "Schaltet {name} stumm, damit du diesen Part selbst spielen oder singen kannst.",
+  "help.solo": "Spielt nur {name}, damit du es deutlich hörst.",
+  "help.download": "Speichert {name} als eigene Audiodatei.",
+  "help.songFactsTitle": "Songdaten",
+  "help.songFacts": "Für dich ermittelt: Tonart, Tempo in BPM, Lautheit, Länge und wie viel von jedem Instrument der Song hat.",
+  "help.wavesTitle": "Wellenformen",
+  "help.waves": "Der Klang jedes Instruments über die Zeit. Klick, um an diese Stelle zu springen. Zieh darüber, um diesen Teil zu loopen.",
+  "help.stop": "Stoppt den Song.",
+  "help.play": "Spielt den Song ab oder pausiert ihn.",
+  "help.loop": "Schaltet den Loop an oder aus: Der Teil zwischen den beiden Zeiten daneben wiederholt sich. Die Taste L tut dasselbe.",
+  "help.loopStart": "Wo der Loop beginnt, in Sekunden. Scroll darüber, um ihn zu verschieben.",
+  "help.loopEnd": "Wo der Loop endet, in Sekunden. Scroll darüber, um ihn zu verschieben.",
+  "help.speedHalf": "Spielt mit halber Geschwindigkeit. Die Tonhöhe bleibt gleich.",
+  "help.speedSlow": "Spielt mit drei Viertel der Geschwindigkeit. Scroll darüber, um jede Geschwindigkeit von 0.50x bis 0.99x zu wählen.",
+  "help.speedNormal": "Spielt in der Originalgeschwindigkeit des Songs.",
+  "help.keyDown": "Senkt den ganzen Song um einen Halbton, den kleinsten Schritt in der Musik.",
+  "help.keyUp": "Hebt den ganzen Song um einen Halbton an, den kleinsten Schritt in der Musik.",
+  "help.keyReset": "Setzt jeden Part zurück in die Originaltonart des Songs.",
+  "help.click": "Schaltet einen Klick an, der dem Tempo des Songs folgt. Die Taste K tut dasselbe.",
+  "help.clickVolume": "Wie laut der Klick ist.",
+  "help.clickMore": "Weitere Einstellungen für den Klick.",
+  "help.export": "Speichert, was du hörst, als eine Audiodatei. Sein Menü bietet auch jeden Part als .zip oder nur den geloopten Teil.",
+  "help.set.language": "Die Sprache der App.",
+  "help.set.maxDuration": "Der längste Song, der angenommen wird, in Minuten.",
+  "help.set.playlistLimit": "Die meisten Songs, die eine Playlist hinzufügt.",
+  "help.set.cookies": "Nur nötig, wenn YouTube verlangt, dass du beweist, kein Bot zu sein.",
+  "help.set.stemsLocation": "Wo deine zerlegten Songs gespeichert werden.",
+  "help.set.exportsLocation": "Wohin Stems und Loops gehen, die du aus StemDeck herausziehst.",
+  "help.set.autoDelete": "Aus, solange du es nicht einschaltest. Löscht Songs nach der Anzahl Tage, die du festlegst.",
+  "help.set.device": "Deine Grafikkarte oder dein Prozessor, für das Zerlegen.",
+  "help.set.quality": "Best liefert sauberere Stems und dauert doppelt so lange.",
+  "help.set.exportLogs": "Alle Logs in einer Zip-Datei, für einen Fehlerbericht.",
+  "help.set.resetData": "Löscht jeden Song. Lässt sich nicht rückgängig machen.",
+  "help.set.acoustid": "Erkennt jeden Song an seinem Klang, mit einem kostenlosen AcoustID-Schlüssel.",
+  "help.set.discogs": "Bandprofile und Veröffentlichungen, mit einem kostenlosen Discogs-Token.",
+  "help.set.transcribe": "Schreibt den Text aus dem Gesang mit, wenn kein Songtext gefunden wird.",
+  "help.set.network": "Öffne StemDeck auf deinem Handy oder Tablet im selben WLAN. Scanne den QR-Code oder tippe die angezeigte Adresse ein.",
+  "help.set.port": "Der Port, auf dem StemDeck läuft. Neustart zum Übernehmen.",
+  "help.set.sampleRate": "Die Abtastrate der Audiodateien, die du exportierst.",
+  "help.set.videoQuality": "Die Qualität der Videos, die du exportierst.",
+  "help.set.logs": "Wo die Logs liegen, und das Anwendungs-, Backend- und Setup-Log.",
+  "help.set.registry": "Die Liste der fertigen Songs, die StemDeck auf der Festplatte führt. Nur lesbar.",
 
   "search.ariaLabel": "Bibliothek durchsuchen",
   "search.placeholder": "Suchen oder #Tag…",
@@ -3612,6 +4023,7 @@ const de = {
   "trash.empty": "Papierkorb leeren",
   "trash.isEmptyState": "Papierkorb ist leer",
   "trash.noSearchMatch": "Keine gelöschten Tracks entsprechen deiner Suche",
+  "trash.holdToRestore": "Linke Maustaste 1 Sekunde halten zum Wiederherstellen",
 
   "meta.key": "Tonart",
   "key.label": "{tonic} {mode}",
@@ -3951,6 +4363,9 @@ const de = {
   "track.untitled": "Unbenannter Track",
   "track.unknown": "Unbekannter Track",
   "track.removed": "Entfernt",
+  "track.stopped": "Gestoppt",
+  "track.extractAgain": "Extrahieren",
+  "track.extractAgainOf": "{title} erneut extrahieren",
   "track.moveToTrash": "In den Papierkorb verschieben",
   "track.moveTitleToTrash": "{title} in den Papierkorb verschieben",
   "track.favorite": "Zu Favoriten hinzufügen",
@@ -4365,6 +4780,7 @@ const pt = {
   "nav.library": "Biblioteca",
   "nav.favorites": "Favoritos",
   "nav.trash": "Lixeira",
+  "nav.trashWithCount": "Lixeira ({count})",
   "nav.importQueue": "Fila de importação",
   "nav.queue": "Fila",
   "nav.settings": "Configurações",
@@ -4372,6 +4788,84 @@ const pt = {
   "nav.weRecommendLine1": "Recomen-",
   "nav.weRecommendLine2": "damos",
   "nav.help": "Ajuda",
+  "help.button": "Explicar a tela",
+  "help.railLabel": "Guia",
+  "help.pill": "Modo ajuda: aponte para qualquer coisa para ver o que faz. Esc para sair.",
+  "help.helpMode": "O modo ajuda está ligado. Aponte ou clique em algo para ver o que faz. Pressione Esc ou este botão para sair.",
+  "help.website": "Abre stemdeck.app no seu navegador.",
+  "help.upload": "Escolha um arquivo de áudio do seu computador para separar em instrumentos.",
+  "help.search": "Digite o nome de uma música para buscar online, ou cole um link. Você também pode soltar um arquivo de áudio aqui.",
+  "help.stemAll": "Extrai todos os instrumentos da música.",
+  "help.stemChip": "Clique para incluir ou deixar de fora {name} na extração.",
+  "help.vocalCombined": "Mantém todo o canto em uma única faixa de Vocais.",
+  "help.vocalSplit": "Separa o canto na voz principal e nos backing vocals.",
+  "help.detectStructure": "Experimental. Ligado, a próxima música importada recebe a intro, os versos e os refrões marcados.",
+  "help.analysisToggle": "Mostra ou esconde a linha de dados da música: tom, andamento, volume e mais.",
+  "help.sectionsToggle": "Mostra ou esconde a barra de seções, onde as partes da música são marcadas.",
+  "help.extract": "Começa a separar a música em instrumentos. Cada um ganha sua própria faixa abaixo.",
+  "help.favorite": "Adiciona a música aberta aos Favoritos, ou a retira.",
+  "help.songDetails": "Detalhes da música aberta.",
+  "help.toggleLibrary": "Esconde a lista de músicas para dar mais espaço ao estúdio, ou a traz de volta.",
+  "help.favorites": "Mostra só as músicas que você marcou com coração.",
+  "help.library": "Mostra todas as suas músicas na lista.",
+  "help.lyrics": "Mostra a letra, iluminada linha por linha enquanto toca.",
+  "help.trash": "As músicas apagadas esperam aqui até você esvaziar a lixeira. O número mostra quantas há.",
+  "help.queue": "As músicas esperando para serem separadas, na ordem em que serão feitas.",
+  "help.notifications": "Mensagens do StemDeck, como uma nova versão ou uma importação que falhou.",
+  "help.recommend": "Artistas, luthiers e equipamentos que vale a pena conhecer. O StemDeck não recebe dinheiro de nenhum deles.",
+  "help.about": "Links para o site, GitHub e Discord, e os créditos.",
+  "help.searchLibrary": "Digite parte do nome de uma música para encontrá-la. Comece com # para buscar por tag.",
+  "help.newFolder": "Cria uma pasta para organizar suas músicas.",
+  "help.trashedSong": "Uma música apagada. Segure-a por um segundo para trazê-la de volta.",
+  "help.song": "Clique em uma música para abri-la no estúdio.",
+  "help.addSection": "Adiciona uma seção, como um verso ou um refrão, à barra de seções.",
+  "help.volume": "Arraste para deixar {name} mais alto ou mais baixo.",
+  "help.laneKeyUp": "Sobe só {name} um semitom, o menor passo na música.",
+  "help.laneKeyDown": "Desce só {name} um semitom, o menor passo na música.",
+  "help.laneKeyTitle": "Tom de {name}",
+  "help.laneKey": "O tom de {name}. K quer dizer o tom original; um número mostra quantos semitons ele mudou.",
+  "help.mute": "Silencia {name}, para você tocar ou cantar essa parte.",
+  "help.solo": "Toca só {name}, para ouvir com clareza.",
+  "help.download": "Salva {name} como um arquivo de áudio separado.",
+  "help.songFactsTitle": "Dados da música",
+  "help.songFacts": "Encontrados para você: o tom, o andamento em BPM, o volume, a duração e quanto há de cada instrumento.",
+  "help.wavesTitle": "Formas de onda",
+  "help.waves": "O som de cada instrumento ao longo do tempo. Clique para pular para esse momento. Arraste para repetir esse trecho em loop.",
+  "help.stop": "Para a música.",
+  "help.play": "Toca a música, ou pausa.",
+  "help.loop": "Liga ou desliga o loop: o trecho entre os dois tempos ao lado se repete. A tecla L faz o mesmo.",
+  "help.loopStart": "Onde o loop começa, em segundos. Role sobre ele para mudar.",
+  "help.loopEnd": "Onde o loop termina, em segundos. Role sobre ele para mudar.",
+  "help.speedHalf": "Toca na metade da velocidade. O tom continua o mesmo.",
+  "help.speedSlow": "Toca a três quartos da velocidade. Role sobre ele para escolher qualquer velocidade de 0.50x a 0.99x.",
+  "help.speedNormal": "Toca na velocidade original da música.",
+  "help.keyDown": "Desce a música inteira um semitom, o menor passo na música.",
+  "help.keyUp": "Sobe a música inteira um semitom, o menor passo na música.",
+  "help.keyReset": "Volta cada parte para o tom original da música.",
+  "help.click": "Liga um clique que segue o andamento da música. A tecla K faz o mesmo.",
+  "help.clickVolume": "O volume do clique.",
+  "help.clickMore": "Mais ajustes do clique.",
+  "help.export": "Salva o que você ouve em um único arquivo de áudio. O menu também oferece cada parte em um .zip, ou só o trecho em loop.",
+  "help.set.language": "O idioma do app.",
+  "help.set.maxDuration": "A música mais longa aceita, em minutos.",
+  "help.set.playlistLimit": "O máximo de músicas que uma playlist adiciona.",
+  "help.set.cookies": "Só é preciso se o YouTube pedir para você provar que não é um robô.",
+  "help.set.stemsLocation": "Onde suas músicas separadas ficam guardadas.",
+  "help.set.exportsLocation": "Para onde vão as faixas e loops que você arrasta para fora do StemDeck.",
+  "help.set.autoDelete": "Desligado a menos que você ligue. Apaga músicas depois do número de dias que você escolher.",
+  "help.set.device": "Sua placa de vídeo ou seu processador, para separar.",
+  "help.set.quality": "Best dá faixas mais limpas e leva o dobro do tempo.",
+  "help.set.exportLogs": "Todos os logs em um zip, para anexar a um relatório de bug.",
+  "help.set.resetData": "Apaga todas as músicas. Não pode ser desfeito.",
+  "help.set.acoustid": "Reconhece cada música pelo som, com uma chave grátis do AcoustID.",
+  "help.set.discogs": "Perfis de bandas e lançamentos, com um token grátis do Discogs.",
+  "help.set.transcribe": "Escreve a letra a partir da voz quando nenhuma é encontrada.",
+  "help.set.network": "Abra o StemDeck no seu celular ou tablet, no mesmo Wi-Fi. Leia o QR code ou digite o endereço mostrado.",
+  "help.set.port": "A porta em que o StemDeck roda. Reinicie para aplicar.",
+  "help.set.sampleRate": "A taxa de amostragem dos arquivos de áudio que você exporta.",
+  "help.set.videoQuality": "A qualidade dos vídeos que você exporta.",
+  "help.set.logs": "Onde ficam os logs, e os logs do aplicativo, do servidor e da instalação.",
+  "help.set.registry": "A lista de músicas prontas que o StemDeck guarda no disco. Só leitura.",
 
   "search.ariaLabel": "Pesquisar biblioteca",
   "search.placeholder": "Pesquisar ou #tag…",
@@ -4395,6 +4889,7 @@ const pt = {
   "trash.empty": "Esvaziar lixeira",
   "trash.isEmptyState": "A lixeira está vazia",
   "trash.noSearchMatch": "Nenhuma faixa excluída corresponde à sua pesquisa",
+  "trash.holdToRestore": "Segure o clique esquerdo por 1 segundo para restaurar",
 
   "meta.key": "Tom",
   "key.label": "{tonic} {mode}",
@@ -4734,6 +5229,9 @@ const pt = {
   "track.untitled": "Faixa sem título",
   "track.unknown": "Faixa desconhecida",
   "track.removed": "Removido",
+  "track.stopped": "Interrompida",
+  "track.extractAgain": "Extrair",
+  "track.extractAgainOf": "Extrair {title} novamente",
   "track.moveToTrash": "Mover para a lixeira",
   "track.moveTitleToTrash": "Mover {title} para a lixeira",
   "track.favorite": "Adicionar aos favoritos",
@@ -5150,6 +5648,7 @@ const id = {
   "nav.library": "Pustaka",
   "nav.favorites": "Favorit",
   "nav.trash": "Sampah",
+  "nav.trashWithCount": "Sampah ({count})",
   "nav.importQueue": "Antrean impor",
   "nav.queue": "Antrean",
   "nav.settings": "Pengaturan",
@@ -5157,6 +5656,84 @@ const id = {
   "nav.weRecommendLine1": "Rekomen-",
   "nav.weRecommendLine2": "dasi",
   "nav.help": "Bantuan",
+  "help.button": "Jelaskan layar",
+  "help.railLabel": "Panduan",
+  "help.pill": "Mode bantuan: arahkan ke apa saja untuk melihat fungsinya. Esc untuk keluar.",
+  "help.helpMode": "Mode bantuan aktif. Arahkan atau klik apa saja untuk melihat fungsinya. Tekan Esc atau tombol ini untuk keluar.",
+  "help.website": "Membuka stemdeck.app di browser Anda.",
+  "help.upload": "Pilih file audio dari komputer Anda untuk dipisahkan menjadi instrumen.",
+  "help.search": "Ketik nama lagu untuk mencarinya secara online, atau tempel tautan. Anda juga bisa menjatuhkan file audio di sini.",
+  "help.stemAll": "Mengekstrak setiap instrumen dalam lagu.",
+  "help.stemChip": "Klik untuk menyertakan atau melewatkan {name} saat mengekstrak.",
+  "help.vocalCombined": "Menyimpan semua nyanyian dalam satu jalur Vokal.",
+  "help.vocalSplit": "Memisahkan nyanyian menjadi vokal utama dan vokal latar.",
+  "help.detectStructure": "Eksperimental. Jika aktif, lagu berikutnya yang Anda impor ditandai intro, bait, dan reff-nya.",
+  "help.analysisToggle": "Menampilkan atau menyembunyikan baris data lagu: kunci nada, tempo, kekerasan suara, dan lainnya.",
+  "help.sectionsToggle": "Menampilkan atau menyembunyikan bilah bagian, tempat bagian-bagian lagu ditandai.",
+  "help.extract": "Mulai memisahkan lagu menjadi instrumen. Masing-masing mendapat jalurnya sendiri di bawah.",
+  "help.favorite": "Menambahkan lagu yang terbuka ke Favorit, atau mengeluarkannya.",
+  "help.songDetails": "Detail tentang lagu yang terbuka.",
+  "help.toggleLibrary": "Menyembunyikan daftar lagu agar studio lebih luas, atau menampilkannya kembali.",
+  "help.favorites": "Hanya menampilkan lagu yang Anda beri hati.",
+  "help.library": "Menampilkan semua lagu Anda di daftar.",
+  "help.lyrics": "Menampilkan lirik lagu, menyala baris demi baris saat diputar.",
+  "help.trash": "Lagu yang dihapus menunggu di sini sampai Anda mengosongkan Sampah. Angkanya menunjukkan jumlahnya.",
+  "help.queue": "Lagu yang menunggu untuk dipisahkan, sesuai urutan pengerjaannya.",
+  "help.notifications": "Pesan dari StemDeck, seperti rilis baru atau impor yang gagal.",
+  "help.recommend": "Artis, pembuat instrumen, dan peralatan yang layak dikenal. StemDeck tidak menerima uang dari mereka.",
+  "help.about": "Tautan ke situs web, GitHub, dan Discord, serta kredit.",
+  "help.searchLibrary": "Ketik sebagian nama lagu untuk menemukannya. Mulai dengan # untuk mencari menurut tag.",
+  "help.newFolder": "Membuat folder untuk mengatur lagu Anda.",
+  "help.trashedSong": "Lagu yang dihapus. Tahan selama satu detik untuk mengembalikannya.",
+  "help.song": "Klik lagu untuk membukanya di studio.",
+  "help.addSection": "Menambahkan bagian, seperti bait atau reff, ke bilah bagian.",
+  "help.volume": "Geser untuk membuat {name} lebih keras atau lebih pelan.",
+  "help.laneKeyUp": "Menaikkan hanya {name} satu semitone, langkah terkecil dalam musik.",
+  "help.laneKeyDown": "Menurunkan hanya {name} satu semitone, langkah terkecil dalam musik.",
+  "help.laneKeyTitle": "Kunci nada {name}",
+  "help.laneKey": "Kunci nada {name}. K berarti kunci aslinya; angka menunjukkan berapa semitone digeser.",
+  "help.mute": "Membisukan {name}, agar Anda bisa memainkan atau menyanyikan bagian itu sendiri.",
+  "help.solo": "Hanya memutar {name}, agar terdengar jelas.",
+  "help.download": "Menyimpan {name} sebagai file audio tersendiri.",
+  "help.songFactsTitle": "Data lagu",
+  "help.songFacts": "Ditemukan untuk Anda: kunci nada, tempo dalam BPM, kekerasan suara, durasi, dan seberapa banyak tiap instrumen.",
+  "help.wavesTitle": "Bentuk gelombang",
+  "help.waves": "Suara tiap instrumen dari waktu ke waktu. Klik untuk melompat ke saat itu. Seret untuk mengulang bagian itu.",
+  "help.stop": "Menghentikan lagu.",
+  "help.play": "Memutar lagu, atau menjedanya.",
+  "help.loop": "Menyalakan atau mematikan pengulangan: bagian di antara dua waktu di sebelahnya diulang. Tombol L melakukan hal yang sama.",
+  "help.loopStart": "Tempat pengulangan dimulai, dalam detik. Gulir di atasnya untuk memindahkannya.",
+  "help.loopEnd": "Tempat pengulangan berakhir, dalam detik. Gulir di atasnya untuk memindahkannya.",
+  "help.speedHalf": "Memutar dengan setengah kecepatan. Nadanya tetap sama.",
+  "help.speedSlow": "Memutar dengan tiga perempat kecepatan. Gulir di atasnya untuk memilih kecepatan dari 0.50x sampai 0.99x.",
+  "help.speedNormal": "Memutar dengan kecepatan asli lagu.",
+  "help.keyDown": "Menurunkan seluruh lagu satu semitone, langkah terkecil dalam musik.",
+  "help.keyUp": "Menaikkan seluruh lagu satu semitone, langkah terkecil dalam musik.",
+  "help.keyReset": "Mengembalikan setiap bagian ke kunci nada asli lagu.",
+  "help.click": "Menyalakan ketukan yang mengikuti tempo lagu. Tombol K melakukan hal yang sama.",
+  "help.clickVolume": "Seberapa keras ketukannya.",
+  "help.clickMore": "Pengaturan lain untuk ketukan.",
+  "help.export": "Menyimpan apa yang Anda dengar sebagai satu file audio. Menunya juga menawarkan setiap bagian sebagai .zip, atau hanya bagian yang diulang.",
+  "help.set.language": "Bahasa aplikasi.",
+  "help.set.maxDuration": "Lagu terpanjang yang diterima, dalam menit.",
+  "help.set.playlistLimit": "Jumlah lagu terbanyak yang ditambahkan satu playlist.",
+  "help.set.cookies": "Hanya diperlukan jika YouTube meminta Anda membuktikan bahwa Anda bukan bot.",
+  "help.set.stemsLocation": "Tempat lagu yang sudah dipisahkan disimpan.",
+  "help.set.exportsLocation": "Tujuan stem dan loop yang Anda seret keluar dari StemDeck.",
+  "help.set.autoDelete": "Mati kecuali Anda menyalakannya. Menghapus lagu setelah jumlah hari yang Anda tentukan.",
+  "help.set.device": "Kartu grafis atau prosesor Anda, untuk memisahkan.",
+  "help.set.quality": "Best memberi stem yang lebih bersih dan butuh waktu dua kali lipat.",
+  "help.set.exportLogs": "Semua log dalam satu zip, untuk dilampirkan ke laporan bug.",
+  "help.set.resetData": "Menghapus semua lagu. Tidak bisa dibatalkan.",
+  "help.set.acoustid": "Mengenali tiap lagu dari suaranya, dengan kunci AcoustID gratis.",
+  "help.set.discogs": "Profil band dan rilisan, dengan token Discogs gratis.",
+  "help.set.transcribe": "Menuliskan lirik dari vokal saat lirik tidak ditemukan.",
+  "help.set.network": "Buka StemDeck di ponsel atau tablet Anda, di Wi-Fi yang sama. Pindai kode QR, atau ketik alamat yang ditampilkan.",
+  "help.set.port": "Port tempat StemDeck berjalan. Mulai ulang untuk menerapkan.",
+  "help.set.sampleRate": "Sample rate file audio yang Anda ekspor.",
+  "help.set.videoQuality": "Kualitas video yang Anda ekspor.",
+  "help.set.logs": "Lokasi log, serta log aplikasi, backend, dan penyiapan.",
+  "help.set.registry": "Daftar lagu selesai yang disimpan StemDeck di disk. Hanya baca.",
 
   "search.ariaLabel": "Cari pustaka",
   "search.placeholder": "Cari atau #tag…",
@@ -5180,6 +5757,7 @@ const id = {
   "trash.empty": "Kosongkan sampah",
   "trash.isEmptyState": "Sampah kosong",
   "trash.noSearchMatch": "Tidak ada trek terhapus yang cocok dengan pencarian Anda",
+  "trash.holdToRestore": "Tahan klik kiri selama 1 detik untuk memulihkan",
 
   "meta.key": "Nada Dasar",
   "key.label": "{tonic} {mode}",
@@ -5514,6 +6092,9 @@ const id = {
   "track.untitled": "Trek tanpa judul",
   "track.unknown": "Trek tidak dikenal",
   "track.removed": "Dihapus",
+  "track.stopped": "Dihentikan",
+  "track.extractAgain": "Ekstrak",
+  "track.extractAgainOf": "Ekstrak ulang {title}",
   "track.moveToTrash": "Pindahkan ke Sampah",
   "track.moveTitleToTrash": "Pindahkan {title} ke Sampah",
   "track.favorite": "Tambahkan ke favorit",
@@ -5922,6 +6503,7 @@ const fr = {
   "nav.library": "Bibliothèque",
   "nav.favorites": "Favoris",
   "nav.trash": "Corbeille",
+  "nav.trashWithCount": "Corbeille ({count})",
   "nav.importQueue": "File d'importation",
   "nav.queue": "File d'attente",
   "nav.settings": "Paramètres",
@@ -5929,6 +6511,84 @@ const fr = {
   "nav.weRecommendLine1": "Nos",
   "nav.weRecommendLine2": "recommandations",
   "nav.help": "Aide",
+  "help.button": "Expliquer l'écran",
+  "help.railLabel": "Guide",
+  "help.pill": "Mode aide : pointez sur un élément pour voir ce qu'il fait. Échap pour quitter.",
+  "help.helpMode": "Le mode aide est activé. Pointez ou cliquez sur un élément pour voir ce qu'il fait. Échap ou ce bouton pour quitter.",
+  "help.website": "Ouvre stemdeck.app dans votre navigateur.",
+  "help.upload": "Choisissez un fichier audio sur votre ordinateur pour le séparer en instruments.",
+  "help.search": "Tapez le nom d'un morceau pour le chercher en ligne, ou collez un lien. Vous pouvez aussi déposer un fichier audio ici.",
+  "help.stemAll": "Extrait tous les instruments du morceau.",
+  "help.stemChip": "Cliquez pour inclure ou exclure {name} lors de l'extraction.",
+  "help.vocalCombined": "Garde tout le chant dans une seule piste Voix.",
+  "help.vocalSplit": "Sépare le chant en voix principale et chœurs.",
+  "help.detectStructure": "Expérimental. Activé, le prochain morceau importé reçoit son intro, ses couplets et ses refrains marqués.",
+  "help.analysisToggle": "Affiche ou masque la ligne d'infos du morceau : tonalité, tempo, volume et plus.",
+  "help.sectionsToggle": "Affiche ou masque la barre des sections, où les parties du morceau sont marquées.",
+  "help.extract": "Lance la séparation du morceau en instruments. Chacun obtient sa propre piste en dessous.",
+  "help.favorite": "Ajoute le morceau ouvert aux Favoris, ou l'en retire.",
+  "help.songDetails": "Détails sur le morceau ouvert.",
+  "help.toggleLibrary": "Masque la liste des morceaux pour agrandir le studio, ou la fait revenir.",
+  "help.favorites": "Affiche seulement les morceaux auxquels vous avez donné un cœur.",
+  "help.library": "Affiche tous vos morceaux dans la liste.",
+  "help.lyrics": "Affiche les paroles, éclairées ligne par ligne pendant la lecture.",
+  "help.trash": "Les morceaux supprimés attendent ici jusqu'à ce que vous vidiez la corbeille. Le nombre indique combien il y en a.",
+  "help.queue": "Les morceaux qui attendent d'être séparés, dans l'ordre où ils seront traités.",
+  "help.notifications": "Messages de StemDeck, comme une nouvelle version ou un import qui a échoué.",
+  "help.recommend": "Artistes, luthiers et matériel à connaître. StemDeck ne reçoit d'argent d'aucun d'eux.",
+  "help.about": "Liens vers le site, GitHub et Discord, et les crédits.",
+  "help.searchLibrary": "Tapez une partie du nom d'un morceau pour le trouver. Commencez par # pour chercher par tag.",
+  "help.newFolder": "Crée un dossier pour ranger vos morceaux.",
+  "help.trashedSong": "Un morceau supprimé. Maintenez-le une seconde pour le récupérer.",
+  "help.song": "Cliquez sur un morceau pour l'ouvrir dans le studio.",
+  "help.addSection": "Ajoute une section, comme un couplet ou un refrain, à la barre des sections.",
+  "help.volume": "Faites glisser pour rendre {name} plus fort ou plus faible.",
+  "help.laneKeyUp": "Monte seulement {name} d'un demi-ton, le plus petit pas en musique.",
+  "help.laneKeyDown": "Descend seulement {name} d'un demi-ton, le plus petit pas en musique.",
+  "help.laneKeyTitle": "Tonalité de {name}",
+  "help.laneKey": "La tonalité de {name}. K signifie sa tonalité d'origine ; un nombre indique de combien de demi-tons elle a bougé.",
+  "help.mute": "Coupe {name}, pour que vous puissiez jouer ou chanter cette partie vous-même.",
+  "help.solo": "Joue seulement {name}, pour l'entendre clairement.",
+  "help.download": "Enregistre {name} comme fichier audio séparé.",
+  "help.songFactsTitle": "Infos du morceau",
+  "help.songFacts": "Trouvés pour vous : la tonalité, le tempo en BPM, le volume, la durée et la présence de chaque instrument.",
+  "help.wavesTitle": "Formes d'onde",
+  "help.waves": "Le son de chaque instrument dans le temps. Cliquez pour aller à ce moment. Faites glisser pour boucler ce passage.",
+  "help.stop": "Arrête le morceau.",
+  "help.play": "Lance le morceau, ou le met en pause.",
+  "help.loop": "Active ou désactive la boucle : le passage entre les deux temps à côté se répète. La touche L fait de même.",
+  "help.loopStart": "Où la boucle commence, en secondes. Faites défiler dessus pour la déplacer.",
+  "help.loopEnd": "Où la boucle finit, en secondes. Faites défiler dessus pour la déplacer.",
+  "help.speedHalf": "Joue à mi-vitesse. La hauteur ne change pas.",
+  "help.speedSlow": "Joue aux trois quarts de la vitesse. Faites défiler dessus pour choisir une vitesse de 0.50x à 0.99x.",
+  "help.speedNormal": "Joue à la vitesse d'origine du morceau.",
+  "help.keyDown": "Descend tout le morceau d'un demi-ton, le plus petit pas en musique.",
+  "help.keyUp": "Monte tout le morceau d'un demi-ton, le plus petit pas en musique.",
+  "help.keyReset": "Remet chaque partie dans la tonalité d'origine du morceau.",
+  "help.click": "Active un clic qui suit le tempo du morceau. La touche K fait de même.",
+  "help.clickVolume": "Le volume du clic.",
+  "help.clickMore": "Plus de réglages pour le clic.",
+  "help.export": "Enregistre ce que vous entendez dans un seul fichier audio. Son menu propose aussi chaque partie en .zip, ou seulement le passage en boucle.",
+  "help.set.language": "La langue de l'application.",
+  "help.set.maxDuration": "Le morceau le plus long accepté, en minutes.",
+  "help.set.playlistLimit": "Le nombre maximum de morceaux qu'ajoute une playlist.",
+  "help.set.cookies": "Utile seulement si YouTube vous demande de prouver que vous n'êtes pas un robot.",
+  "help.set.stemsLocation": "Où sont stockés vos morceaux séparés.",
+  "help.set.exportsLocation": "Où vont les pistes et boucles que vous faites glisser hors de StemDeck.",
+  "help.set.autoDelete": "Désactivé sauf si vous l'activez. Supprime les morceaux après le nombre de jours choisi.",
+  "help.set.device": "Votre carte graphique ou votre processeur, pour la séparation.",
+  "help.set.quality": "Best donne des pistes plus propres et prend deux fois plus de temps.",
+  "help.set.exportLogs": "Tous les journaux dans un zip, à joindre à un rapport de bug.",
+  "help.set.resetData": "Supprime tous les morceaux. Impossible à annuler.",
+  "help.set.acoustid": "Reconnaît chaque morceau à son son, avec une clé AcoustID gratuite.",
+  "help.set.discogs": "Profils de groupes et sorties, avec un jeton Discogs gratuit.",
+  "help.set.transcribe": "Écrit les paroles à partir du chant quand aucune n'est trouvée.",
+  "help.set.network": "Ouvrez StemDeck sur votre téléphone ou tablette, sur le même Wi-Fi. Scannez le QR code ou tapez l'adresse affichée.",
+  "help.set.port": "Le port sur lequel StemDeck tourne. Redémarrez pour appliquer.",
+  "help.set.sampleRate": "La fréquence d'échantillonnage des fichiers audio exportés.",
+  "help.set.videoQuality": "La qualité des vidéos exportées.",
+  "help.set.logs": "Où sont les journaux, et les journaux de l'application, du serveur et de l'installation.",
+  "help.set.registry": "La liste des morceaux terminés que StemDeck garde sur le disque. Lecture seule.",
 
   "search.ariaLabel": "Rechercher dans la bibliothèque",
   "search.placeholder": "Rechercher ou #tag…",
@@ -5952,6 +6612,7 @@ const fr = {
   "trash.empty": "Vider la corbeille",
   "trash.isEmptyState": "La corbeille est vide",
   "trash.noSearchMatch": "Aucun morceau supprimé ne correspond à votre recherche",
+  "trash.holdToRestore": "Maintenez le clic gauche 1 seconde pour restaurer",
 
   "meta.key": "Tonalité",
   "key.label": "{tonic} {mode}",
@@ -6291,6 +6952,9 @@ const fr = {
   "track.untitled": "Morceau sans titre",
   "track.unknown": "Morceau inconnu",
   "track.removed": "Supprimé",
+  "track.stopped": "Arrêté",
+  "track.extractAgain": "Extraire",
+  "track.extractAgainOf": "Extraire à nouveau {title}",
   "track.moveToTrash": "Mettre à la corbeille",
   "track.moveTitleToTrash": "Mettre {title} à la corbeille",
   "track.favorite": "Ajouter aux favoris",
@@ -6879,6 +7543,7 @@ const es = {
   "nav.library": "Biblioteca",
   "nav.favorites": "Favoritos",
   "nav.trash": "Papelera",
+  "nav.trashWithCount": "Papelera ({count})",
   "nav.importQueue": "Cola de importación",
   "nav.queue": "Cola",
   "nav.settings": "Ajustes",
@@ -6886,6 +7551,84 @@ const es = {
   "nav.weRecommendLine1": "Reco-",
   "nav.weRecommendLine2": "mendamos",
   "nav.help": "Ayuda",
+  "help.button": "Explicar la pantalla",
+  "help.railLabel": "Guía",
+  "help.pill": "Modo ayuda: señala cualquier cosa para ver qué hace. Esc para salir.",
+  "help.helpMode": "El modo ayuda está activado. Señala o haz clic en algo para ver qué hace. Pulsa Esc o este botón para salir.",
+  "help.website": "Abre stemdeck.app en tu navegador.",
+  "help.upload": "Elige un archivo de audio de tu ordenador para separarlo en sus instrumentos.",
+  "help.search": "Escribe el nombre de una canción para buscarla en línea, o pega un enlace. También puedes soltar aquí un archivo de audio.",
+  "help.stemAll": "Extrae todos los instrumentos de la canción.",
+  "help.stemChip": "Haz clic para incluir o dejar fuera {name} al extraer.",
+  "help.vocalCombined": "Mantiene todo el canto en una sola pista de Voces.",
+  "help.vocalSplit": "Separa el canto en la voz principal y los coros.",
+  "help.detectStructure": "Experimental. Activado, la próxima canción que importes tendrá marcados la intro, las estrofas y los estribillos.",
+  "help.analysisToggle": "Muestra u oculta la fila de datos de la canción: tonalidad, tempo, volumen y más.",
+  "help.sectionsToggle": "Muestra u oculta la barra de secciones, donde se marcan las partes de la canción.",
+  "help.extract": "Empieza a separar la canción en sus instrumentos. Cada uno tiene su propia pista abajo.",
+  "help.favorite": "Añade la canción abierta a Favoritos, o la quita.",
+  "help.songDetails": "Detalles de la canción abierta.",
+  "help.toggleLibrary": "Oculta la lista de canciones para dar más espacio al estudio, o la vuelve a mostrar.",
+  "help.favorites": "Muestra solo las canciones a las que diste un corazón.",
+  "help.library": "Muestra todas tus canciones en la lista.",
+  "help.lyrics": "Muestra la letra, iluminada línea a línea mientras suena.",
+  "help.trash": "Las canciones borradas esperan aquí hasta que vacíes la papelera. El número indica cuántas hay.",
+  "help.queue": "Las canciones que esperan para separarse, en el orden en que se harán.",
+  "help.notifications": "Mensajes de StemDeck, como una nueva versión o una importación que falló.",
+  "help.recommend": "Artistas, luthiers y equipo que vale la pena conocer. StemDeck no recibe dinero de ninguno de ellos.",
+  "help.about": "Enlaces a la web, GitHub y Discord, y los créditos.",
+  "help.searchLibrary": "Escribe parte del nombre de una canción para encontrarla. Empieza con # para buscar por etiqueta.",
+  "help.newFolder": "Crea una carpeta para ordenar tus canciones.",
+  "help.trashedSong": "Una canción borrada. Mantenla pulsada un segundo para recuperarla.",
+  "help.song": "Haz clic en una canción para abrirla en el estudio.",
+  "help.addSection": "Añade una sección, como una estrofa o un estribillo, a la barra de secciones.",
+  "help.volume": "Arrastra para subir o bajar el volumen de {name}.",
+  "help.laneKeyUp": "Sube solo {name} un semitono, el paso más pequeño en música.",
+  "help.laneKeyDown": "Baja solo {name} un semitono, el paso más pequeño en música.",
+  "help.laneKeyTitle": "Tonalidad de {name}",
+  "help.laneKey": "La tonalidad de {name}. K es su tonalidad original; un número indica cuántos semitonos se movió.",
+  "help.mute": "Silencia {name}, para que puedas tocar o cantar esa parte tú.",
+  "help.solo": "Reproduce solo {name}, para oírlo con claridad.",
+  "help.download": "Guarda {name} como un archivo de audio aparte.",
+  "help.songFactsTitle": "Datos de la canción",
+  "help.songFacts": "Calculados para ti: la tonalidad, el tempo en BPM, el volumen, la duración y cuánto hay de cada instrumento.",
+  "help.wavesTitle": "Formas de onda",
+  "help.waves": "El sonido de cada instrumento a lo largo del tiempo. Haz clic para saltar a ese momento. Arrastra para repetir esa parte en bucle.",
+  "help.stop": "Detiene la canción.",
+  "help.play": "Reproduce la canción, o la pausa.",
+  "help.loop": "Activa o desactiva el bucle: la parte entre los dos tiempos de al lado se repite. La tecla L hace lo mismo.",
+  "help.loopStart": "Dónde empieza el bucle, en segundos. Desplaza la rueda encima para moverlo.",
+  "help.loopEnd": "Dónde termina el bucle, en segundos. Desplaza la rueda encima para moverlo.",
+  "help.speedHalf": "Reproduce a media velocidad. El tono no cambia.",
+  "help.speedSlow": "Reproduce a tres cuartos de velocidad. Desplaza la rueda encima para elegir cualquier velocidad de 0.50x a 0.99x.",
+  "help.speedNormal": "Reproduce a la velocidad original de la canción.",
+  "help.keyDown": "Baja toda la canción un semitono, el paso más pequeño en música.",
+  "help.keyUp": "Sube toda la canción un semitono, el paso más pequeño en música.",
+  "help.keyReset": "Devuelve cada parte a la tonalidad original de la canción.",
+  "help.click": "Activa un clic que sigue el tempo de la canción. La tecla K hace lo mismo.",
+  "help.clickVolume": "El volumen del clic.",
+  "help.clickMore": "Más ajustes del clic.",
+  "help.export": "Guarda lo que oyes como un solo archivo de audio. Su menú también ofrece cada parte en un .zip, o solo la parte en bucle.",
+  "help.set.language": "El idioma de la aplicación.",
+  "help.set.maxDuration": "La canción más larga que acepta, en minutos.",
+  "help.set.playlistLimit": "El máximo de canciones que añade una lista de reproducción.",
+  "help.set.cookies": "Solo hace falta si YouTube te pide demostrar que no eres un bot.",
+  "help.set.stemsLocation": "Dónde se guardan tus canciones separadas.",
+  "help.set.exportsLocation": "Adónde van las pistas y bucles que arrastras fuera de StemDeck.",
+  "help.set.autoDelete": "Desactivado salvo que lo actives. Borra canciones tras el número de días que elijas.",
+  "help.set.device": "Tu tarjeta gráfica o tu procesador, para separar.",
+  "help.set.quality": "Best da pistas más limpias y tarda el doble.",
+  "help.set.exportLogs": "Todos los registros en un zip, para adjuntar a un informe de error.",
+  "help.set.resetData": "Borra todas las canciones. No se puede deshacer.",
+  "help.set.acoustid": "Reconoce cada canción por su sonido, con una clave gratuita de AcoustID.",
+  "help.set.discogs": "Perfiles de bandas y lanzamientos, con un token gratuito de Discogs.",
+  "help.set.transcribe": "Escribe la letra a partir de la voz cuando no se encuentra ninguna.",
+  "help.set.network": "Abre StemDeck en tu móvil o tableta, en la misma Wi-Fi. Escanea el código QR o escribe la dirección que aparece.",
+  "help.set.port": "El puerto en el que funciona StemDeck. Reinicia para aplicarlo.",
+  "help.set.sampleRate": "La frecuencia de muestreo de los archivos de audio que exportas.",
+  "help.set.videoQuality": "La calidad de los vídeos que exportas.",
+  "help.set.logs": "Dónde están los registros, y los registros de la aplicación, del servidor y de la instalación.",
+  "help.set.registry": "La lista de canciones terminadas que StemDeck guarda en el disco. Solo lectura.",
 
   "search.ariaLabel": "Buscar en la biblioteca",
   "search.placeholder": "Busca o #etiqueta…",
@@ -6909,6 +7652,7 @@ const es = {
   "trash.empty": "Vaciar papelera",
   "trash.isEmptyState": "La papelera está vacía",
   "trash.noSearchMatch": "Ninguna pista eliminada coincide con tu búsqueda",
+  "trash.holdToRestore": "Mantén pulsado el clic izquierdo 1 segundo para restaurar",
 
   "meta.key": "Tonalidad",
   "key.label": "{tonic} {mode}",
@@ -7249,6 +7993,9 @@ const es = {
   "track.untitled": "Pista sin título",
   "track.unknown": "Pista desconocida",
   "track.removed": "Eliminada",
+  "track.stopped": "Detenida",
+  "track.extractAgain": "Extraer",
+  "track.extractAgainOf": "Volver a extraer {title}",
   "track.moveToTrash": "Mover a la papelera",
   "track.moveTitleToTrash": "Mover {title} a la papelera",
   "track.favorite": "Añadir a favoritos",
@@ -7685,6 +8432,7 @@ const ko = {
   "nav.library": "라이브러리",
   "nav.favorites": "즐겨찾기",
   "nav.trash": "휴지통",
+  "nav.trashWithCount": "휴지통 ({count})",
   "nav.importQueue": "가져오기 대기열",
   "nav.queue": "대기열",
   "nav.settings": "설정",
@@ -7692,6 +8440,84 @@ const ko = {
   "nav.weRecommendLine1": "이런 곳도",
   "nav.weRecommendLine2": "추천해요",
   "nav.help": "도움말",
+  "help.button": "화면 설명",
+  "help.railLabel": "가이드",
+  "help.pill": "도움말 모드: 아무 항목이나 가리키면 하는 일을 보여 줘요. Esc로 나가요.",
+  "help.helpMode": "도움말 모드가 켜져 있어요. 아무 항목이나 가리키거나 클릭하면 하는 일을 보여 줘요. Esc나 이 버튼으로 끌 수 있어요.",
+  "help.website": "브라우저에서 stemdeck.app을 열어요.",
+  "help.upload": "컴퓨터에서 오디오 파일을 골라 악기별로 나눠요.",
+  "help.search": "곡 이름을 입력해 온라인에서 찾거나 링크를 붙여 넣어요. 오디오 파일을 여기에 놓을 수도 있어요.",
+  "help.stemAll": "곡에 있는 모든 악기를 추출해요.",
+  "help.stemChip": "클릭해서 추출할 때 {name}을(를) 넣거나 뺄 수 있어요.",
+  "help.vocalCombined": "모든 노래를 보컬 레인 하나에 담아요.",
+  "help.vocalSplit": "노래를 리드 보컬과 백 보컬로 나눠요.",
+  "help.detectStructure": "실험 기능이에요. 켜면 다음에 가져오는 곡의 인트로, 벌스, 코러스가 표시돼요.",
+  "help.analysisToggle": "키, 템포, 음량 등 곡 정보 줄을 보이거나 숨겨요.",
+  "help.sectionsToggle": "곡의 구간이 표시되는 섹션 막대를 보이거나 숨겨요.",
+  "help.extract": "곡을 악기별로 나누기 시작해요. 악기마다 아래에 레인이 생겨요.",
+  "help.favorite": "열린 곡을 즐겨찾기에 넣거나 빼요.",
+  "help.songDetails": "열린 곡의 자세한 정보예요.",
+  "help.toggleLibrary": "곡 목록을 숨겨 스튜디오를 넓게 쓰거나 다시 보여 줘요.",
+  "help.favorites": "하트를 누른 곡만 보여 줘요.",
+  "help.library": "목록에 모든 곡을 보여 줘요.",
+  "help.lyrics": "곡의 가사를 보여 주고, 재생에 맞춰 한 줄씩 밝혀 줘요.",
+  "help.trash": "삭제한 곡은 휴지통을 비울 때까지 여기에 있어요. 숫자는 곡 수예요.",
+  "help.queue": "분리를 기다리는 곡이에요. 처리될 순서대로 있어요.",
+  "help.notifications": "새 버전이나 실패한 가져오기 같은 StemDeck의 알림이에요.",
+  "help.recommend": "알아 두면 좋은 아티스트, 악기 제작자, 장비예요. StemDeck은 이들 누구에게서도 돈을 받지 않아요.",
+  "help.about": "웹사이트, GitHub, Discord 링크와 크레딧이에요.",
+  "help.searchLibrary": "곡 이름 일부를 입력해 찾아요. #으로 시작하면 태그로 찾아요.",
+  "help.newFolder": "곡을 정리할 폴더를 만들어요.",
+  "help.trashedSong": "삭제한 곡이에요. 1초 동안 누르고 있으면 되살아나요.",
+  "help.song": "곡을 클릭하면 스튜디오에서 열려요.",
+  "help.addSection": "벌스나 코러스 같은 구간을 섹션 막대에 추가해요.",
+  "help.volume": "끌어서 {name} 소리를 키우거나 줄여요.",
+  "help.laneKeyUp": "{name}만 반음 올려요. 반음은 음악에서 가장 작은 음 간격이에요.",
+  "help.laneKeyDown": "{name}만 반음 내려요. 반음은 음악에서 가장 작은 음 간격이에요.",
+  "help.laneKeyTitle": "{name}의 키",
+  "help.laneKey": "{name}의 키예요. K는 원래 키이고, 숫자는 몇 반음 옮겼는지 보여 줘요.",
+  "help.mute": "{name} 소리를 꺼서 그 부분을 직접 연주하거나 부를 수 있게 해요.",
+  "help.solo": "{name}만 재생해서 또렷하게 들려줘요.",
+  "help.download": "{name}을(를) 별도의 오디오 파일로 저장해요.",
+  "help.songFactsTitle": "곡 정보",
+  "help.songFacts": "자동으로 찾아 줘요: 키, BPM 단위의 템포, 음량, 길이, 그리고 악기별 비중이에요.",
+  "help.wavesTitle": "파형",
+  "help.waves": "악기마다 소리를 시간에 따라 그린 거예요. 클릭하면 그 순간으로 가고, 끌면 그 부분을 반복해요.",
+  "help.stop": "곡을 멈춰요.",
+  "help.play": "곡을 재생하거나 일시 정지해요.",
+  "help.loop": "반복을 켜거나 꺼요. 옆의 두 시간 사이가 반복돼요. L 키도 같아요.",
+  "help.loopStart": "반복이 시작하는 곳이에요(초). 위에서 스크롤하면 옮길 수 있어요.",
+  "help.loopEnd": "반복이 끝나는 곳이에요(초). 위에서 스크롤하면 옮길 수 있어요.",
+  "help.speedHalf": "절반 속도로 재생해요. 음높이는 그대로예요.",
+  "help.speedSlow": "4분의 3 속도로 재생해요. 위에서 스크롤하면 0.50x에서 0.99x까지 고를 수 있어요.",
+  "help.speedNormal": "곡의 원래 속도로 재생해요.",
+  "help.keyDown": "곡 전체를 반음 내려요. 반음은 음악에서 가장 작은 음 간격이에요.",
+  "help.keyUp": "곡 전체를 반음 올려요. 반음은 음악에서 가장 작은 음 간격이에요.",
+  "help.keyReset": "모든 부분을 곡의 원래 키로 되돌려요.",
+  "help.click": "곡의 템포를 따라가는 클릭을 켜요. K 키도 같아요.",
+  "help.clickVolume": "클릭 소리의 크기예요.",
+  "help.clickMore": "클릭의 다른 설정이에요.",
+  "help.export": "들리는 그대로 오디오 파일 하나로 저장해요. 메뉴에서 모든 부분을 .zip으로, 또는 반복 구간만 저장할 수도 있어요.",
+  "help.set.language": "앱의 언어예요.",
+  "help.set.maxDuration": "받아들이는 가장 긴 곡 길이예요(분).",
+  "help.set.playlistLimit": "재생목록 하나가 추가하는 최대 곡 수예요.",
+  "help.set.cookies": "YouTube가 봇이 아님을 확인해 달라고 할 때만 필요해요.",
+  "help.set.stemsLocation": "분리한 곡을 저장하는 곳이에요.",
+  "help.set.exportsLocation": "StemDeck 밖으로 끌어낸 스템과 루프가 저장되는 곳이에요.",
+  "help.set.autoDelete": "직접 켜기 전에는 꺼져 있어요. 정한 날짜가 지나면 곡을 삭제해요.",
+  "help.set.device": "분리에 쓰는 그래픽 카드나 프로세서예요.",
+  "help.set.quality": "Best는 스템이 더 깨끗하고 시간이 두 배 걸려요.",
+  "help.set.exportLogs": "모든 로그를 zip 하나로 묶어요. 버그 신고에 첨부할 수 있어요.",
+  "help.set.resetData": "모든 곡을 삭제해요. 되돌릴 수 없어요.",
+  "help.set.acoustid": "무료 AcoustID 키로 소리를 듣고 곡을 알아봐요.",
+  "help.set.discogs": "무료 Discogs 토큰으로 밴드 프로필과 발매 정보를 가져와요.",
+  "help.set.transcribe": "가사를 찾지 못하면 보컬에서 가사를 받아 적어요.",
+  "help.set.network": "같은 Wi-Fi에 있는 휴대폰이나 태블릿에서 StemDeck을 열어요. QR 코드를 찍거나 표시된 주소를 입력해요.",
+  "help.set.port": "StemDeck이 실행되는 포트예요. 다시 시작하면 적용돼요.",
+  "help.set.sampleRate": "내보내는 오디오 파일의 샘플 레이트예요.",
+  "help.set.videoQuality": "내보내는 동영상의 화질이에요.",
+  "help.set.logs": "로그 위치와 앱, 백엔드, 설치 로그예요.",
+  "help.set.registry": "StemDeck이 디스크에 보관하는 완료된 곡 목록이에요. 읽기 전용이에요.",
 
   "search.ariaLabel": "라이브러리 검색",
   "search.placeholder": "검색 또는 #태그…",
@@ -7715,6 +8541,7 @@ const ko = {
   "trash.empty": "휴지통 비우기",
   "trash.isEmptyState": "휴지통이 비어 있어요",
   "trash.noSearchMatch": "검색과 맞는 삭제된 트랙이 없어요",
+  "trash.holdToRestore": "왼쪽 클릭을 1초 동안 누르면 복원돼요",
 
   "meta.key": "키",
   "key.label": "{tonic} {mode}",
@@ -8049,6 +8876,9 @@ const ko = {
   "track.untitled": "제목 없는 트랙",
   "track.unknown": "알 수 없는 트랙",
   "track.removed": "삭제됨",
+  "track.stopped": "중지됨",
+  "track.extractAgain": "추출",
+  "track.extractAgainOf": "{title} 다시 추출",
   "track.moveToTrash": "휴지통으로 옮기기",
   "track.moveTitleToTrash": "{title}을(를) 휴지통으로 옮기기",
   "track.favorite": "즐겨찾기에 추가",
diff --git a/static/js/job.js b/static/js/job.js
index e6bd9e53..a74e615f 100644
--- a/static/js/job.js
+++ b/static/js/job.js
@@ -3,13 +3,12 @@ import {
   jobDetailEl, jobCancelBtn, progressEl, titleEl, bpmChip, keyChip,
   eventSource, setEventSource, setCurrentJobId,
   foregroundJobId, setForegroundJobId,
-  audioEngine, multitrack,
   selectedStems, vocalSplitMode,
 } from "./state.js";
 import { destroyPlayer, wireUpAudio, setWaveformLoading, updateFooterTrack } from "./player.js";
 import { notifyFailure, dismissFailuresByJobId } from "./notifications.js";
 import { getStagePhrases } from "./phrases.js";
-import { addTrackToLibrary, setCurrentTrack, updateTrackStatus, applyStemPresenceCards, libraryAudioTags, libraryArtist, libraryIdentity, libraryWork, paintFinishedTrackNames } from "./catalog.js";
+import { addTrackToLibrary, setCurrentTrack, updateTrackStatus, applyStemPresenceCards, libraryAudioTags, libraryArtist, libraryIdentity, libraryWork, paintFinishedTrackNames, armAutoOpen } from "./catalog.js";
 import { initSections } from "./sections.js";
 import { importPlaylist, looksLikePlaylist } from "./playlist.js";
 import { t } from "./i18n.js";
@@ -86,7 +85,7 @@ export async function runVocalSplitIfWanted(state) {
   }
 }
 
-const TERMINAL_STATUSES = new Set(["done", "error", "cancelled"]);
+const TERMINAL_STATUSES = new Set(["done", "error", "cancelled", "stopped"]);
 
 // Last library-visible values written per job, so a 4 Hz progress stream does
 // not re-run addTrackToLibrary (a full localStorage write plus a whole-sidebar
@@ -120,13 +119,6 @@ function setSubmitProcessing(processing) {
   if (label) label.textContent = processing ? t("job.processing") : t("process.extractStems");
 }
 
-/** True when audio is loaded in the studio. Either engine counts: the Web Audio
- *  path sets audioEngine, the streaming path sets multitrack, and destroyPlayer
- *  clears both. Read at call time so the live bindings are current. */
-function studioHasTrack() {
-  return !!(audioEngine || multitrack);
-}
-
 function pickPhrase(status) {
   const stagePhrases = getStagePhrases();
   const pool = stagePhrases[status] || stagePhrases.default;
@@ -506,9 +498,11 @@ function applyState(state) {
       },
     });
     setForegroundJobId(null);
-  } else if (state.status === "cancelled") {
+  } else if (state.status === "cancelled" || state.status === "stopped") {
+    // "stopped" is a job put in the Trash while it ran (#748): it ends here the
+    // same way, but its row keeps saying so, since its files are kept.
     stopJobPolling();
-    updateTrackStatus(state.job_id, "cancelled");
+    updateTrackStatus(state.job_id, state.status);
     setWaveformLoading(false);
     jobBox.classList.add("hidden");
     setForegroundJobId(null);
@@ -670,6 +664,7 @@ function registerUploadRow(jobId, file) {
     peakDb: null,
     sourceUrl,
   });
+  armAutoOpen(jobId);
 }
 
 function sanitizeFilename(name) {
@@ -747,24 +742,15 @@ export function wireJobForm() {
   form.addEventListener("submit", async (e) => {
     e.preventDefault();
 
-    // An import must never take a loaded studio away from the user. With a
-    // track playing, the new job goes straight to the background: no player
-    // teardown, no loading overlay, no takeover when it finishes. It reports
-    // progress on its library row instead.
+    // An import never takes the studio, loaded or empty (#747). It runs in the
+    // background and reports on its library row and the queue; the card and the
+    // loading overlay stay as they are. If the studio is still empty when it
+    // finishes, catalog.js opens it then (see armAutoOpen).
     //
-    // An import already holding the foreground keeps it, too. Otherwise
-    // queueing a second track would point the studio overlay at a job that has
-    // not started, and the first import -- the one about to finish -- would no
-    // longer be the one that loads.
-    const background = studioHasTrack() || !!foregroundJobId;
-    if (background) {
-      // Deliberately NOT resetImportUi(): that closes the running import's
-      // event stream and drops its foreground claim, which would leave the job
-      // about to finish with nothing listening for its completion.
-      clearImportError();
-    } else {
-      reset();
-    }
+    // Deliberately NOT resetImportUi(): that closes the event stream of an
+    // import still holding the foreground (a "Sync again" restore), which would
+    // leave the job about to finish with nothing listening for its completion.
+    clearImportError();
     setSubmitProcessing(true);
 
     const fileInput = document.getElementById("fileInput");
@@ -783,12 +769,10 @@ export function wireJobForm() {
     }
     // Several files dropped at once: upload them one after another. Parallel
     // uploads of several 400 MB bodies would thrash memory on both ends, and
-    // the endpoint takes exactly one file per request anyway. The first one
-    // takes the studio if it is free, exactly as a single import would; the
-    // rest queue behind it.
+    // the endpoint takes exactly one file per request anyway. All of them run
+    // in the background; the first to finish opens if the studio is still empty.
     const batch = fileInput?._files ?? null;
     if (batch && batch.length > 1) {
-      if (!background) setWaveformLoading(true, "Uploading…");
       let queued = 0;
       let failure = null;
       for (const item of batch) {
@@ -796,16 +780,6 @@ export function wireJobForm() {
           const id = await postFileJob(item);
           registerUploadRow(id, item);
           queued += 1;
-          if (queued === 1 && !background) {
-            setCurrentJobId(id);
-            setForegroundJobId(id);
-            setCurrentTrack(id);
-            jobBox.classList.add("hidden");
-            jobCancelBtn.classList.add("hidden");
-            startPhraseRotation("queued");
-            lastStatus = "queued";
-            connectEvents(id);
-          }
         } catch (err) {
           failure = err;
           break; // a full queue will reject the rest too; stop asking
@@ -814,10 +788,6 @@ export function wireJobForm() {
       setSubmitProcessing(false);
       fileInput._clear?.();
       if (failure) {
-        if (!queued && !background) {
-          setWaveformLoading(false);
-          setForegroundJobId(null);
-        }
         showError(
           `Queued ${queued} of ${batch.length} files: ${failure.message}`,
           null,
@@ -844,20 +814,6 @@ export function wireJobForm() {
       ? submitBtn.dataset.resplitTitle || t("job.processingTrackTitle")
       : (sanitized ?? (urlInput.value || t("job.processingTrackTitle")));
 
-    const postUrlText = document.getElementById("post-url-text");
-    if (postUrlText) postUrlText.textContent = displayTitle;
-
-    // Show overlay immediately for both paths. File uploads show "Uploading…"
-    // in the overlay phrase until the fetch completes and SSE takes over.
-    // Skipped entirely for a background import -- the overlay covers the
-    // studio, which is exactly what must not happen here.
-    if (!background) {
-      setWaveformLoading(true, file ? "Uploading…" : "");
-      if (file) {
-        lastStatus = "queued";
-      }
-    }
-
     let endpoint = "/api/jobs";
     let fetchInit;
     if (resplitJob) {
@@ -898,7 +854,6 @@ export function wireJobForm() {
       jobId = data.job_id;
       if (data.source_url) newSourceUrl = data.source_url;
     } catch (err) {
-      if (file) jobBox.classList.add("hidden");
       showError(t("job.startFailed", { message: err.message }));
       setSubmitProcessing(false);
       return;
@@ -929,26 +884,10 @@ export function wireJobForm() {
       sourceUrl: newSourceUrl,
     });
 
-    if (background) {
-      // No per-job stream: opening one per queued import would burn through
-      // the browser's ~6 connections per origin and starve stem loading. The
-      // shared queue stream drives the row, and catalog.js completes the
-      // library entry when the job leaves the queue.
-      if (postUrlText) postUrlText.textContent = "";
-      return;
-    }
-
-    setCurrentJobId(jobId);
-    setForegroundJobId(jobId);
-    setCurrentTrack(jobId);
-
-    // Keep job box hidden, overlay drives the UI. Start phrase rotation now
-    // that the job exists on the server.
-    jobBox.classList.add("hidden");
-    jobCancelBtn.classList.add("hidden");
-    startPhraseRotation("queued");
-    lastStatus = "queued";
-
-    connectEvents(jobId);
+    // No per-job stream: opening one per queued import would burn through the
+    // browser's ~6 connections per origin and starve stem loading. The shared
+    // queue stream drives the row, and catalog.js completes the library entry
+    // when the job leaves the queue.
+    armAutoOpen(jobId);
   });
 }
diff --git a/static/js/main.js b/static/js/main.js
index fccb50fd..684d650f 100644
--- a/static/js/main.js
+++ b/static/js/main.js
@@ -21,6 +21,7 @@ import { initI18n, applyTranslations, t, plural, onLanguageChange } from "./i18n
 import { initFooterFit, refitFooter } from "./footerFit.js";
 import { initArtistInfo } from "./artistInfo.js";
 import { initLyrics } from "./lyrics.js";
+import { initHelpMode } from "./helpMode.js";
 
 // ─── Stem choice toggles on the import page ───
 //
@@ -456,6 +457,7 @@ wireAppShellControls();
 initFooterFit();
 initArtistInfo();
 initLyrics();
+initHelpMode();
 // Re-measure after a language switch. Measured across en/fr/de/pl the strip
 // came out the same width in all four, because the group labels are 10px
 // uppercase and narrower than the controls under them, so this is not the
diff --git a/static/mobile/app.js b/static/mobile/app.js
index 7bcf4f1e..de4aca92 100644
--- a/static/mobile/app.js
+++ b/static/mobile/app.js
@@ -591,8 +591,10 @@ function extractProgressCard() {
   const pct = Math.round((j.progress || 0) * 100);
   const failed = j.status === "error";
   const cancelled = j.status === "cancelled";
+  // Trashed while it ran (#748): halted, its files kept for the desktop's Trash.
+  const stopped = j.status === "stopped";
   const done = j.status === "done";
-  const line = failed ? "Failed" : cancelled ? "Cancelled" : done ? "Done" : `${j.stage || j.status}…`;
+  const line = failed ? "Failed" : cancelled ? "Cancelled" : stopped ? "Stopped" : done ? "Done" : `${j.stage || j.status}…`;
   return `<div class="eyebrow">IN PROGRESS</div>
     <div class="progress-card">
       <div class="progress-top">
@@ -718,7 +720,7 @@ function _onExtractState(jobId, s) {
   state.extractJob.progress = s.progress || 0;
   state.extractJob.stage = s.stage || s.status;
   if (state.tab === "extract") render();
-  if (s.status === "done" || s.status === "error" || s.status === "cancelled") {
+  if (["done", "error", "cancelled", "stopped"].includes(s.status)) {
     if (s.status === "done" && state.extractJob.vocalSplitMode === "split") {
       _runVocalSplitThenFinish(jobId);
     } else {
diff --git a/tests/e2e/artist-from-server.spec.mjs b/tests/e2e/artist-from-server.spec.mjs
index 296a5b93..8c961ef4 100644
--- a/tests/e2e/artist-from-server.spec.mjs
+++ b/tests/e2e/artist-from-server.spec.mjs
@@ -15,6 +15,7 @@ import {
   seedCatalogState,
   stubAudioTags,
   stubExportEndpoints,
+  stubImportQueue,
   stubUpdateCheck,
 } from "./helpers.mjs";
 
@@ -106,24 +107,22 @@ test.describe("band found by the server during the import", () => {
   test("a finished import shows its band at once, with nothing asked of Wikimedia", async ({ page }) => {
     const asked = await stubWikimedia(page);
     const doneState = await stubServerBand(page, JOB_ID);
-    // The import: the server accepts it as the fixture job, and its event
-    // stream says it is done, carrying the band the pipeline found.
+    // The import: the server accepts it as the fixture job. It runs in the
+    // background (#747), so the queue says when it is done and the page then
+    // fetches its state, which carries the band the pipeline found.
     await page.route("**/api/jobs", (route) => {
       if (route.request().method() !== "POST") return route.fallback();
       return route.fulfill({ status: 200, contentType: "application/json", body: JSON.stringify({ job_id: JOB_ID }) });
     });
-    await page.route(`**/api/jobs/${JOB_ID}/events`, async (route) =>
-      route.fulfill({
-        status: 200,
-        contentType: "text/event-stream",
-        body: `data: ${JSON.stringify(await doneState())}\n\n`,
-      }));
-    // Only the sibling is in the library, so nothing is open and the import
-    // takes the studio.
+    const queue = await stubImportQueue(page, JOB_ID);
+    // Only the sibling is in the library, so nothing is open and the finished
+    // import opens itself.
     await openPage(page, { [SIBLING_JOB_ID]: fixtureTrack(SIBLING_JOB_ID, "E2E Fixture Track (again)") });
 
     await page.locator("#url").fill("https://www.youtube.com/watch?v=dQw4w9WgXcQ");
     await page.locator("#submit").click();
+    await queue.run();
+    await queue.settle();
 
     await expect(page.locator(".app")).not.toHaveClass(/no-track/, { timeout: 15000 });
     await expect(page.locator("#np-artist")).toHaveText("Dream Theater", { timeout: 15000 });
diff --git a/tests/e2e/help-mode.spec.mjs b/tests/e2e/help-mode.spec.mjs
new file mode 100644
index 00000000..cdf7ac3b
--- /dev/null
+++ b/tests/e2e/help-mode.spec.mjs
@@ -0,0 +1,99 @@
+// Help mode: Guide in the rail, below Trash, makes the studio explain itself. Every
+// control it covers shows an outline, pointing at one shows a box with its
+// name and what it does, and a click while help mode is on explains instead of
+// acting.
+
+import { test, expect } from "@playwright/test";
+
+import { openStudio } from "./helpers.mjs";
+
+const tip = (page) => page.locator("#helpTip");
+
+async function helpOn(page) {
+  await page.locator("#helpModeBtn").click();
+  await expect(page.locator("body")).toHaveClass(/help-mode/);
+  await expect(page.locator("#helpModeBtn")).toHaveAttribute("aria-pressed", "true");
+  await expect(page.locator(".help-pill")).toBeVisible();
+}
+
+test.describe("help mode", () => {
+  test("Guide turns it on, and Esc or Guide turns it off", async ({ page }) => {
+    await openStudio(page);
+    await helpOn(page);
+    await page.keyboard.press("Escape");
+    await expect(page.locator("body")).not.toHaveClass(/help-mode/);
+    await helpOn(page);
+    await page.locator("#helpModeBtn").click();
+    await expect(page.locator("body")).not.toHaveClass(/help-mode/);
+    await expect(page.locator(".help-target")).toHaveCount(0);
+    await expect(page.locator(".help-pill")).toBeHidden();
+  });
+
+  test("pointing at a control explains it, under its own label", async ({ page }) => {
+    await openStudio(page);
+    await helpOn(page);
+    await page.locator("#t-speed-075").hover();
+    await expect(tip(page)).toBeVisible();
+    await expect(tip(page).locator("b")).toHaveText("0.75x");
+    await expect(tip(page)).toContainText("three-quarter speed");
+    await expect(page.locator("#t-speed-075")).toHaveClass(/help-current/);
+  });
+
+  test("a lane's control names its instrument", async ({ page }) => {
+    await openStudio(page);
+    await helpOn(page);
+    const drumsMute = page.locator(".mx-row, .lane-header").filter({ hasText: "Drums" }).locator(".mx-btn.mute").first();
+    await drumsMute.hover();
+    await expect(tip(page)).toContainText("Silences Drums");
+    // Headed by what the button does, not by its one letter.
+    await expect(tip(page).locator("b")).toHaveText("Mute Drums");
+
+    const drumsKey = page.locator(".lane-key").filter({ has: page.locator('[aria-label*="Drums"]') }).locator(".lane-key-value").first();
+    await drumsKey.hover({ force: true });
+    await expect(tip(page).locator("b")).toHaveText("Key of Drums");
+  });
+
+  test("a click explains instead of acting", async ({ page }) => {
+    await openStudio(page);
+    await helpOn(page);
+    const fav = page.locator("#fav-btn");
+    await expect(fav).toHaveAttribute("aria-pressed", "false");
+    await fav.click();
+    await expect(tip(page)).toContainText("Favorites");
+    await expect(fav).toHaveAttribute("aria-pressed", "false");
+
+    // Off again, the same click works.
+    await page.keyboard.press("Escape");
+    await fav.click();
+    await expect(fav).toHaveAttribute("aria-pressed", "true");
+  });
+
+  test("Settings lists every tab and its options", async ({ page }) => {
+    await openStudio(page);
+    await helpOn(page);
+    await page.locator("#settingsBtn").hover();
+    for (const text of ["General", "Song details", "Network", "Export", "Logs", "Registry", "Port", "Compute device", "Make StemDeck available on your network"]) {
+      await expect(tip(page)).toContainText(text);
+    }
+  });
+
+  test("every outlined control has a title and a real explanation", async ({ page }) => {
+    await openStudio(page);
+    await helpOn(page);
+    const targets = page.locator(".help-target");
+    const count = await targets.count();
+    expect(count).toBeGreaterThan(40);
+    const bad = [];
+    for (let i = 0; i < count; i++) {
+      const el = targets.nth(i);
+      if (!(await el.isVisible())) continue;
+      // Hover the centre of the box, which for the small lane steppers is the
+      // only point not shared with a neighbour.
+      await el.hover({ force: true });
+      const title = (await tip(page).locator("b").textContent())?.trim();
+      const text = (await tip(page).textContent())?.trim();
+      if (!title || !text || /help\.|\{name\}/.test(text) || text === title) bad.push({ i, title, text });
+    }
+    expect(bad).toEqual([]);
+  });
+});
diff --git a/tests/e2e/helpers.mjs b/tests/e2e/helpers.mjs
index 56eb46f3..f740869b 100644
--- a/tests/e2e/helpers.mjs
+++ b/tests/e2e/helpers.mjs
@@ -409,3 +409,38 @@ export async function stubLyricsLookup(page, { rows = [], artist = "", song = ""
   });
   return asked;
 }
+
+/**
+ * Stand in for the import queue, for a test that has to watch an import while
+ * it runs. The e2e backend never separates anything, so a job that stays
+ * "running" long enough to look at cannot be produced for real.
+ *
+ * `run()` reports the job as running and `settle()` as gone, each followed by a
+ * queue read so the page sees it at once. The queue stream is held off, or its
+ * own empty frames would override the stub.
+ */
+export async function stubImportQueue(page, jobId, title = "Importing") {
+  let running = false;
+  await page.route("**/api/queue", (route) =>
+    route.fulfill({
+      status: 200,
+      contentType: "application/json",
+      body: JSON.stringify({
+        running: running
+          ? { job_id: jobId, status: "separating", stage: "Separating 40%", progress: 0.4, title }
+          : null,
+        queued: [],
+        paused: false,
+        max_pending_uploads: 5,
+        max_pending_urls: 50,
+        capacity_left_uploads: 5,
+        capacity_left_urls: 50,
+      }),
+    }));
+  await page.route("**/api/queue/events", (route) => route.abort());
+  const read = () => page.evaluate(async () => (await import("/js/queue.js")).refreshQueue());
+  return {
+    run: async () => { running = true; await read(); },
+    settle: async () => { running = false; await read(); },
+  };
+}
diff --git a/tests/e2e/import-background.spec.mjs b/tests/e2e/import-background.spec.mjs
new file mode 100644
index 00000000..a4ec1150
--- /dev/null
+++ b/tests/e2e/import-background.spec.mjs
@@ -0,0 +1,99 @@
+// An import never takes the studio while it runs (#747). With nothing open it
+// used to put the song's name and "Extracting" on the Now Playing card; now the
+// card stays empty, the progress lives on the library row and the queue, and the
+// finished track opens by itself if the studio is still empty.
+//
+// The queue is stubbed (see stubImportQueue): the e2e backend never separates.
+// The finished job is the seeded fixture, so its stems are real files.
+import { test, expect } from "@playwright/test";
+
+import {
+  JOB_ID,
+  SIBLING_JOB_ID,
+  TRACK_TITLE,
+  SIBLING_TITLE,
+  fixtureTrack,
+  seedCatalogState,
+  stubExportEndpoints,
+  stubImportQueue,
+  stubUpdateCheck,
+} from "./helpers.mjs";
+
+test.use({ viewport: { width: 1600, height: 900 } });
+
+// Only the sibling is in the store, so the import's own row is new and nothing
+// is dedup-folded into it (#542).
+async function seedSibling(page) {
+  await seedCatalogState(page, {
+    folders: [
+      { id: "f-unsorted", name: "Unsorted", items: [SIBLING_JOB_ID], color: null },
+      { id: "trash", name: "Trash", items: [], color: null },
+    ],
+    tracks: { [SIBLING_JOB_ID]: fixtureTrack(SIBLING_JOB_ID, SIBLING_TITLE) },
+  });
+}
+
+async function startImport(page) {
+  await page.route("**/api/jobs", (route) => {
+    if (route.request().method() !== "POST") return route.fallback();
+    return route.fulfill({ status: 200, contentType: "application/json", body: JSON.stringify({ job_id: JOB_ID }) });
+  });
+  const queue = await stubImportQueue(page, JOB_ID, "Importing Song");
+  await stubExportEndpoints(page);
+  await stubUpdateCheck(page);
+  await page.goto("/", { waitUntil: "domcontentloaded" });
+  await page.locator(".cat-item").first().waitFor({ timeout: 20000 });
+  await page.locator("#url").fill("https://www.youtube.com/watch?v=dQw4w9WgXcQ");
+  await page.locator("#submit").click();
+  await queue.run();
+  return queue;
+}
+
+test.describe("an import with the studio empty", () => {
+  test("keeps the Now Playing card empty while it runs, then opens the track", async ({ page }) => {
+    await seedSibling(page);
+    const queue = await startImport(page);
+
+    await expect(page.locator(".app")).toHaveClass(/no-track/);
+    await expect(page.locator("#title")).toHaveText("Ready to import a track");
+    const card = page.locator("#nowPlayingPanel");
+    await expect(card).not.toContainText("Importing Song");
+    await expect(card).not.toContainText(/extracting/i);
+    // The progress is on the library row instead.
+    await expect(page.locator(`.cat-item[data-id="${JOB_ID}"]`).first()).toBeVisible();
+
+    await queue.settle();
+    await expect(page.locator(".app")).not.toHaveClass(/no-track/, { timeout: 15000 });
+    await expect(page.locator("#title")).toHaveText(TRACK_TITLE, { timeout: 15000 });
+  });
+
+  test("does not open the finished track over one the user opened meanwhile", async ({ page }) => {
+    await seedSibling(page);
+    const queue = await startImport(page);
+
+    await page.locator(`.cat-item[data-id="${SIBLING_JOB_ID}"]`).first().click();
+    await expect(page.locator("#title")).toHaveText(SIBLING_TITLE, { timeout: 15000 });
+
+    await queue.settle();
+    await page.waitForTimeout(1500);
+    await expect(page.locator("#title")).toHaveText(SIBLING_TITLE);
+  });
+
+  test("does not take the studio from a Sync again import holding it", async ({ page }) => {
+    await seedSibling(page);
+    const queue = await startImport(page);
+
+    // "Sync again" tears the player down and claims the studio by id, with no
+    // engine loaded. Set that claim the way importFromUrl does, through the
+    // same module instance the app uses.
+    await page.evaluate(async () => {
+      const state = await import("/js/state.js");
+      state.setForegroundJobId("aaaaaaaaaaaa");
+    });
+
+    await queue.settle();
+    await page.waitForTimeout(1500);
+    await expect(page.locator(".app")).toHaveClass(/no-track/);
+    await expect(page.locator("#title")).not.toHaveText(TRACK_TITLE);
+  });
+});
diff --git a/tests/e2e/library-rows.spec.mjs b/tests/e2e/library-rows.spec.mjs
index e284cc62..92c82969 100644
--- a/tests/e2e/library-rows.spec.mjs
+++ b/tests/e2e/library-rows.spec.mjs
@@ -89,7 +89,17 @@ test.describe("library rows", () => {
     await expect(page.locator(`.cat-item[data-id="${JOB_ID}"]`)).toHaveCount(0);
   });
 
+  // The library asks the server where every "processing" row stands on load
+  // (#748), and the seeded job is done there. These rows test the label of a
+  // job that really is still running, so the server has to say so too.
+  async function serverSaysSeparating(page) {
+    await page.route(`**/api/jobs/${JOB_ID}`, (route) =>
+      route.fulfill({ json: { job_id: JOB_ID, status: "separating", progress: 0.4 } }),
+    );
+  }
+
   test("a track still being processed says so", async ({ page }) => {
+    await serverSaysSeparating(page);
     await seedCatalogState(
       page,
       withTracks({ ...fixtureTrack(JOB_ID, "Busy"), status: "separating" }),
@@ -98,6 +108,18 @@ test.describe("library rows", () => {
     expect(await rowText(page, JOB_ID)).toBe("Processing");
   });
 
+  test("a row left processing by a closed app takes the server's answer", async ({ page }) => {
+    // #748: a job that finished, failed or stopped while the app was closed
+    // never left the queue in front of the page, so its row said Processing
+    // for good. The seeded job is done on the server.
+    await seedCatalogState(
+      page,
+      withTracks({ ...fixtureTrack(JOB_ID, "Stale"), status: "separating" }),
+    );
+    await open(page);
+    await expect.poll(() => rowText(page, JOB_ID)).not.toBe("Processing");
+  });
+
   test("a failed import says so", async ({ page }) => {
     await seedCatalogState(
       page,
@@ -108,6 +130,7 @@ test.describe("library rows", () => {
   });
 
   test("the line follows the language rather than keeping the one it was saved in", async ({ page }) => {
+    await serverSaysSeparating(page);
     await page.addInitScript(() =>
       localStorage.setItem("stemdeck.language", JSON.stringify("de")),
     );
diff --git a/tests/e2e/trash-queue.spec.mjs b/tests/e2e/trash-queue.spec.mjs
new file mode 100644
index 00000000..3710b3a0
--- /dev/null
+++ b/tests/e2e/trash-queue.spec.mjs
@@ -0,0 +1,107 @@
+// Trashing an import that is still in the queue (#748), and what the Trash
+// says about files on disk (#749).
+//
+// The queue is stubbed rather than driven: the e2e backend never runs a real
+// separation, so a job that stays "running" long enough to click on cannot be
+// produced against it. The server half (trash cancels the job) is covered by
+// tests/test_jobs_trash.py; this covers what the page does around it.
+
+import { test, expect } from "@playwright/test";
+
+import { fixtureTrack, seedCatalogState, stubUpdateCheck } from "./helpers.mjs";
+
+const RUNNING_ID = "e2e0feedf00d";
+const RUNNING_TITLE = "Still Importing";
+
+function queueFrame(running) {
+  return {
+    running: running
+      ? { job_id: RUNNING_ID, status: "analyzing", stage: "Analyzing audio...", progress: 0, title: RUNNING_TITLE }
+      : null,
+    queued: [],
+    paused: false,
+    max_pending_uploads: 5,
+    max_pending_urls: 50,
+    capacity_left_uploads: 5,
+    capacity_left_urls: 50,
+  };
+}
+
+/**
+ * A library holding one import that the queue reports as running, until the
+ * page trashes it. Counts the queue reads, so a test can tell a refresh that
+ * followed the trash from one that was already going to happen.
+ */
+async function seedRunningImport(page) {
+  await seedCatalogState(page, {
+    folders: [
+      { id: "f-unsorted", name: "Unsorted", items: [RUNNING_ID], color: null },
+      { id: "trash", name: "Trash", items: [], color: null },
+    ],
+    // Its own source, or the startup sync's dedup-by-source (#542) folds it
+    // into the seeded fixture job and the row under test is gone.
+    tracks: {
+      [RUNNING_ID]: {
+        ...fixtureTrack(RUNNING_ID, RUNNING_TITLE),
+        status: "analyzing",
+        sourceUrl: "local:still-importing",
+      },
+    },
+  });
+  await stubUpdateCheck(page);
+
+  const seen = { trashed: false, queueReadsAfterTrash: 0 };
+  await page.route(`**/api/jobs/${RUNNING_ID}/trash`, (route) => {
+    seen.trashed = true;
+    return route.fulfill({
+      status: 200,
+      contentType: "application/json",
+      body: JSON.stringify({ job_id: RUNNING_ID, trashed_at: 1 }),
+    });
+  });
+  await page.route("**/api/queue", (route) => {
+    if (seen.trashed) seen.queueReadsAfterTrash += 1;
+    return route.fulfill({
+      status: 200,
+      contentType: "application/json",
+      body: JSON.stringify(queueFrame(!seen.trashed)),
+    });
+  });
+  // The stream is held off so the only queue reads are the ones the page asks
+  // for, which is what the refresh test counts.
+  await page.route("**/api/queue/events", (route) => route.abort());
+  return seen;
+}
+
+test("a queue row offers the same trash can as the library rows", async ({ page }) => {
+  await seedRunningImport(page);
+  await page.goto("/", { waitUntil: "domcontentloaded" });
+
+  await page.locator(".rail-queue").click();
+  const cancel = page.locator(`.queue-row[data-id="${RUNNING_ID}"] .queue-cancel`);
+  await expect(cancel).toBeVisible();
+  // The library's trash can, not the old X (#748).
+  await expect(cancel.locator('polyline[points="3 6 5 6 21 6"]')).toHaveCount(1);
+  await expect(cancel.locator('path[d="M18 6 6 18 M6 6l12 12"]')).toHaveCount(0);
+});
+
+test("trashing an import that is still running refreshes the queue at once", async ({ page }) => {
+  const seen = await seedRunningImport(page);
+  await page.goto("/", { waitUntil: "domcontentloaded" });
+
+  // The first read has to have landed, or the page does not yet know the
+  // track is in the queue and has no reason to refresh it.
+  await page.locator(".rail-queue").click();
+  await expect(page.locator(`.queue-row[data-id="${RUNNING_ID}"]`)).toBeVisible();
+  await page.locator(".rail-library").click();
+
+  // The row's actions only take the pointer on hover (#724).
+  const row = page.locator(`.cat-item[data-id="${RUNNING_ID}"]`);
+  await row.hover();
+  await row.locator(".cat-del").click();
+
+  await expect.poll(() => seen.queueReadsAfterTrash).toBeGreaterThan(0);
+  // The stream is aborted, so only the refresh the trash asked for can have
+  // told the page the queue is empty, which hides the queue button.
+  await expect(page.locator(".rail-queue")).toHaveClass(/(^| )hidden( |$)/);
+});
diff --git a/tests/e2e/trash-restore.spec.mjs b/tests/e2e/trash-restore.spec.mjs
new file mode 100644
index 00000000..88a1019d
--- /dev/null
+++ b/tests/e2e/trash-restore.spec.mjs
@@ -0,0 +1,240 @@
+// The Trash: hovering a row shows how to restore it, a click picks rows
+// (Ctrl adds one, Shift takes a range), and holding the mouse button for a
+// second restores the row, or the whole selection it belongs to. The Trash
+// icon carries a count, so a full Trash is visible from anywhere (#749).
+//
+// The server's trash and restore endpoints are stubbed and recorded. The real
+// ones would leave the shared fixture jobs trashed on the server, and the next
+// spec's startup sync would move them out of its library.
+
+import { test, expect } from "@playwright/test";
+
+import {
+  JOB_ID,
+  SIBLING_JOB_ID,
+  TRACK_TITLE,
+  fixtureTrack,
+  readCatalogState,
+  seedCatalogState,
+  stubUpdateCheck,
+} from "./helpers.mjs";
+
+const THIRD_ID = "e2e0feedface";
+const TRASHED = [JOB_ID, SIBLING_JOB_ID, THIRD_ID];
+
+async function seedFullTrash(page) {
+  await seedCatalogState(page, {
+    folders: [
+      { id: "f-unsorted", name: "Unsorted", items: [], color: null },
+      { id: "trash", name: "Trash", items: [...TRASHED], color: null },
+    ],
+    tracks: {
+      [JOB_ID]: fixtureTrack(JOB_ID, TRACK_TITLE),
+      [SIBLING_JOB_ID]: fixtureTrack(SIBLING_JOB_ID, "Second Trashed"),
+      [THIRD_ID]: { ...fixtureTrack(THIRD_ID, "Third Trashed"), sourceUrl: "local:third.wav" },
+    },
+  });
+  await stubUpdateCheck(page);
+  const calls = [];
+  await page.route(/\/api\/jobs\/[^/]+\/(trash|restore)$/, (route) => {
+    const [, id, action] = route.request().url().match(/\/api\/jobs\/([^/]+)\/(trash|restore)$/);
+    calls.push({ id, action });
+    return route.fulfill({ status: 200, contentType: "application/json", body: "{}" });
+  });
+  return calls;
+}
+
+async function openTrash(page) {
+  await page.goto("/", { waitUntil: "domcontentloaded" });
+  await page.locator(".rail-trash").click();
+  await expect(page.locator("#catalogPanel")).toHaveClass(/trash-view/);
+  for (const id of TRASHED) await expect(trashRow(page, id)).toBeVisible();
+}
+
+const trashRow = (page, id) => page.locator(`#catalogList .cat-item.in-trash[data-id="${id}"]`);
+const restoreCalls = (calls) => calls.filter((c) => c.action === "restore").map((c) => c.id).sort();
+
+/** Press and hold on a row for `ms`, then let go. */
+async function holdOn(page, id, ms) {
+  const box = await trashRow(page, id).boundingBox();
+  await page.mouse.move(box.x + box.width / 2, box.y + box.height / 2);
+  await page.mouse.down();
+  await page.waitForTimeout(ms);
+  await page.mouse.up();
+}
+
+test.describe("the Trash icon", () => {
+  test("shows how many songs are in the Trash", async ({ page }) => {
+    await seedFullTrash(page);
+    await page.goto("/", { waitUntil: "domcontentloaded" });
+    const badge = page.locator("#trashBadge");
+    await expect(badge).toBeVisible();
+    await expect(badge).toHaveText("3");
+    await expect(page.locator(".rail-trash")).toHaveAttribute("aria-label", "Trash (3)");
+  });
+
+  test("shows no count when the Trash is empty", async ({ page }) => {
+    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),
+        [SIBLING_JOB_ID]: fixtureTrack(SIBLING_JOB_ID, "Second"),
+      },
+    });
+    await stubUpdateCheck(page);
+    await page.goto("/", { waitUntil: "domcontentloaded" });
+    await expect(page.locator(".cat-item").first()).toBeVisible();
+    await expect(page.locator("#trashBadge")).toBeHidden();
+    await expect(page.locator(".rail-trash")).toHaveAttribute("aria-label", "Trash");
+  });
+});
+
+test.describe("a Trash row", () => {
+  test("looks like a library row at rest, and shows the hint on hover", async ({ page }) => {
+    await seedFullTrash(page);
+    await openTrash(page);
+    const row = trashRow(page, JOB_ID);
+    const hint = row.locator(".trash-hint");
+    const line = row.locator(".cat-sub:not(.trash-hint)");
+    await page.mouse.move(0, 0);
+    await expect(row.locator(".cat-meta")).toHaveCSS("filter", "none");
+    await expect(line).toBeVisible();
+    await expect(hint).toBeHidden();
+
+    await row.hover();
+    await expect(hint).toBeVisible();
+    await expect(hint).toHaveText("Hold left click for 1 second to restore");
+    await expect(line).toBeHidden();
+  });
+
+  test("a click selects it and does not open the song", async ({ page }) => {
+    const calls = await seedFullTrash(page);
+    await openTrash(page);
+    await trashRow(page, JOB_ID).click();
+    await expect(trashRow(page, JOB_ID)).toHaveClass(/selected/);
+    await expect(trashRow(page, JOB_ID)).toHaveAttribute("aria-selected", "true");
+    await expect(page.locator(".app")).toHaveClass(/no-track/);
+    expect(restoreCalls(calls)).toEqual([]);
+  });
+
+  test("Ctrl+click picks several, and Ctrl+click again drops one", async ({ page }) => {
+    await seedFullTrash(page);
+    await openTrash(page);
+    await trashRow(page, JOB_ID).click();
+    await trashRow(page, THIRD_ID).click({ modifiers: ["Control"] });
+    await expect(trashRow(page, JOB_ID)).toHaveClass(/selected/);
+    await expect(trashRow(page, THIRD_ID)).toHaveClass(/selected/);
+    await expect(trashRow(page, SIBLING_JOB_ID)).not.toHaveClass(/selected/);
+
+    await trashRow(page, JOB_ID).click({ modifiers: ["Control"] });
+    await expect(trashRow(page, JOB_ID)).not.toHaveClass(/selected/);
+    await expect(trashRow(page, THIRD_ID)).toHaveClass(/selected/);
+  });
+
+  test("Shift+click picks the range from the last row picked", async ({ page }) => {
+    await seedFullTrash(page);
+    await openTrash(page);
+    const order = await page.locator("#catalogList .cat-item.in-trash").evaluateAll((els) => els.map((e) => e.dataset.id));
+    await trashRow(page, order[0]).click();
+    await trashRow(page, order[2]).click({ modifiers: ["Shift"] });
+    for (const id of order) await expect(trashRow(page, id)).toHaveClass(/selected/);
+
+    // A plain click starts over with that row alone.
+    await trashRow(page, order[1]).click();
+    await expect(trashRow(page, order[1])).toHaveClass(/selected/);
+    await expect(trashRow(page, order[0])).not.toHaveClass(/selected/);
+    await expect(trashRow(page, order[2])).not.toHaveClass(/selected/);
+  });
+
+  test("let go before a second and nothing is restored", async ({ page }) => {
+    const calls = await seedFullTrash(page);
+    await openTrash(page);
+    await holdOn(page, JOB_ID, 400);
+    await page.waitForTimeout(900);
+    await expect(trashRow(page, JOB_ID)).toBeVisible();
+    expect(restoreCalls(calls)).toEqual([]);
+  });
+
+  test("held for a second, it leaves the Trash for the library", async ({ page }) => {
+    const calls = await seedFullTrash(page);
+    await openTrash(page);
+    await holdOn(page, JOB_ID, 1300);
+    await expect(trashRow(page, JOB_ID)).toHaveCount(0);
+    await expect(trashRow(page, SIBLING_JOB_ID)).toBeVisible();
+    await expect.poll(() => restoreCalls(calls)).toEqual([JOB_ID]);
+    await expect(page.locator("#trashBadge")).toHaveText("2");
+
+    const state = await readCatalogState(page);
+    expect(state.folders.find((f) => f.id === "trash").items).not.toContain(JOB_ID);
+    expect(state.folders.find((f) => f.id === "f-unsorted").items).toContain(JOB_ID);
+  });
+
+  test("held on a selected row, the whole selection is restored", async ({ page }) => {
+    const calls = await seedFullTrash(page);
+    await openTrash(page);
+    await trashRow(page, JOB_ID).click();
+    await trashRow(page, THIRD_ID).click({ modifiers: ["Control"] });
+    await holdOn(page, THIRD_ID, 1300);
+    await expect(trashRow(page, JOB_ID)).toHaveCount(0);
+    await expect(trashRow(page, THIRD_ID)).toHaveCount(0);
+    await expect(trashRow(page, SIBLING_JOB_ID)).toBeVisible();
+    await expect.poll(() => restoreCalls(calls)).toEqual([JOB_ID, THIRD_ID].sort());
+    await expect(page.locator("#trashBadge")).toHaveText("1");
+  });
+
+  test("held on a selected row, every selected row shows the fill, and letting go clears it", async ({ page }) => {
+    await seedFullTrash(page);
+    await openTrash(page);
+    await trashRow(page, JOB_ID).click();
+    await trashRow(page, THIRD_ID).click({ modifiers: ["Control"] });
+    const box = await trashRow(page, THIRD_ID).boundingBox();
+    await page.mouse.move(box.x + box.width / 2, box.y + box.height / 2);
+    await page.mouse.down();
+    await expect(trashRow(page, JOB_ID)).toHaveClass(/holding/);
+    await expect(trashRow(page, THIRD_ID)).toHaveClass(/holding/);
+    await expect(trashRow(page, SIBLING_JOB_ID)).not.toHaveClass(/holding/);
+    await page.mouse.up();
+    await expect(trashRow(page, JOB_ID)).not.toHaveClass(/holding/);
+    await expect(trashRow(page, THIRD_ID)).not.toHaveClass(/holding/);
+  });
+
+  test("held on a row outside the selection, only that row shows the fill", async ({ page }) => {
+    await seedFullTrash(page);
+    await openTrash(page);
+    await trashRow(page, JOB_ID).click();
+    await trashRow(page, THIRD_ID).click({ modifiers: ["Control"] });
+    const box = await trashRow(page, SIBLING_JOB_ID).boundingBox();
+    await page.mouse.move(box.x + box.width / 2, box.y + box.height / 2);
+    await page.mouse.down();
+    await expect(trashRow(page, SIBLING_JOB_ID)).toHaveClass(/holding/);
+    await expect(trashRow(page, JOB_ID)).not.toHaveClass(/holding/);
+    await expect(trashRow(page, THIRD_ID)).not.toHaveClass(/holding/);
+    await page.mouse.up();
+  });
+
+  test("held on a row outside the selection, only that row is restored", async ({ page }) => {
+    const calls = await seedFullTrash(page);
+    await openTrash(page);
+    await trashRow(page, JOB_ID).click();
+    await trashRow(page, THIRD_ID).click({ modifiers: ["Control"] });
+    await holdOn(page, SIBLING_JOB_ID, 1300);
+    await expect(trashRow(page, SIBLING_JOB_ID)).toHaveCount(0);
+    await expect(trashRow(page, JOB_ID)).toBeVisible();
+    await expect(trashRow(page, THIRD_ID)).toBeVisible();
+    await expect.poll(() => restoreCalls(calls)).toEqual([SIBLING_JOB_ID]);
+  });
+
+  test("holding Enter on a focused row restores it too", async ({ page }) => {
+    const calls = await seedFullTrash(page);
+    await openTrash(page);
+    await trashRow(page, JOB_ID).focus();
+    await page.keyboard.down("Enter");
+    await page.waitForTimeout(1300);
+    await page.keyboard.up("Enter");
+    await expect(trashRow(page, JOB_ID)).toHaveCount(0);
+    await expect.poll(() => restoreCalls(calls)).toEqual([JOB_ID]);
+  });
+});
diff --git a/tests/e2e/work-info.spec.mjs b/tests/e2e/work-info.spec.mjs
index 9437fa67..a8a17610 100644
--- a/tests/e2e/work-info.spec.mjs
+++ b/tests/e2e/work-info.spec.mjs
@@ -15,6 +15,7 @@ import {
   seedCatalogState,
   stubAudioTags,
   stubExportEndpoints,
+  stubImportQueue,
   stubUpdateCheck,
 } from "./helpers.mjs";
 
@@ -323,12 +324,14 @@ test.describe("the work a soundtrack is from", () => {
       route.request().method() === "POST"
         ? route.fulfill({ status: 200, contentType: "application/json", body: JSON.stringify({ job_id: JOB_ID }) })
         : route.fallback());
-    await page.route(`**/api/jobs/${JOB_ID}/events`, (route) =>
-      route.fulfill({ status: 200, contentType: "text/event-stream", body: `data: ${JSON.stringify(done)}\n\n` }));
+    // The import runs in the background (#747); the queue says when it is done.
+    const queue = await stubImportQueue(page, JOB_ID);
     const tagAsks = await openPage(page, { [SIBLING_JOB_ID]: fixtureTrack(SIBLING_JOB_ID, "E2E Fixture Track (again)") });
 
     await page.locator("#url").fill("https://www.youtube.com/watch?v=6Nn8rBmhDjE");
     await page.locator("#submit").click();
+    await queue.run();
+    await queue.settle();
 
     await expect(page.locator("#title")).toHaveText("Popular", { timeout: 15000 });
     await expect(page.locator("#np-artist")).toHaveText("Wicked", { timeout: 15000 });
diff --git a/tests/test_cancellation_reach.py b/tests/test_cancellation_reach.py
index 8f0a79b8..c2099714 100644
--- a/tests/test_cancellation_reach.py
+++ b/tests/test_cancellation_reach.py
@@ -15,7 +15,7 @@
 from app.core import process as _process
 from app.core.models import Job
 from app.core.registry import register as registry_register
-from app.pipeline import runner as _runner
+from app.pipeline import cancel as _cancel
 
 
 def _job(**kw):
@@ -30,10 +30,10 @@ def _capture(job_id, proc):
         seen.setdefault("during", proc if proc is not None else seen.get("during"))
         seen["last"] = proc
 
-    monkeypatch.setattr(_runner, "set_proc", _capture)
+    monkeypatch.setattr(_cancel, "set_proc", _capture)
 
     job = _job()
-    rc, _ = _runner._run_registered_ffmpeg(job, ["sh", "-c", "exit 0"], 30)
+    rc = _cancel.run_registered(job, ["sh", "-c", "exit 0"], 30).returncode
 
     assert rc == 0
     assert seen["during"] is not None, "cancel could not have reached this process"
@@ -42,10 +42,11 @@ def _capture(job_id, proc):
 
 def test_a_failing_command_still_deregisters(tmp_path, monkeypatch):
     cleared = []
-    monkeypatch.setattr(_runner, "set_proc", lambda job_id, proc: cleared.append(proc))
+    monkeypatch.setattr(_cancel, "set_proc", lambda job_id, proc: cleared.append(proc))
 
     job = _job()
-    rc, stderr = _runner._run_registered_ffmpeg(job, ["sh", "-c", "echo boom >&2; exit 3"], 30)
+    result = _cancel.run_registered(job, ["sh", "-c", "echo boom >&2; exit 3"], 30)
+    rc, stderr = result.returncode, result.stderr
 
     assert rc == 3
     assert b"boom" in stderr, "stderr must still be captured for the error message"
@@ -168,3 +169,85 @@ def test_cancelling_a_plain_done_job_still_does_nothing(monkeypatch):
 
     assert not proc.terminated
     assert job.cancel_requested is False
+
+
+# ─── the cancelled job's folder (#749) ───
+
+
+async def test_a_locked_file_does_not_leave_a_cancelled_jobs_folder_behind(tmp_path, monkeypatch):
+    """Right after a cancel terminates ffmpeg or the demucs worker, Windows can
+    still hold one of its files. One attempt left the folder on disk for good,
+    the orphan #749 reported; the removal is retried like delete_job's."""
+    import shutil
+
+    from app.core.models import JobCancelled
+    from app.pipeline import collect as _collect
+    from app.pipeline import runner as _runner
+
+    job = _job(cancel_requested=True)
+    registry_register(job)
+    job_dir = tmp_path / job.id
+    (job_dir / "stems").mkdir(parents=True)
+    (job_dir / "stems" / "vocals.wav").write_bytes(b"RIFF")
+
+    real_rmtree = shutil.rmtree
+    attempts = []
+
+    def locked_once(path, *a, **k):
+        attempts.append(path)
+        if len(attempts) == 1:
+            raise PermissionError(32, "The process cannot access the file", str(path))
+        return real_rmtree(path, *a, **k)
+
+    monkeypatch.setattr(_collect.shutil, "rmtree", locked_once)
+
+    def cancelled(_job, _job_dir):
+        raise JobCancelled()
+
+    await _runner._run_async(job, job_dir, tmp_path, cancelled)
+
+    assert job.status == "cancelled"
+    assert len(attempts) == 2, "the lock must be retried, not given up on"
+    assert not job_dir.exists(), "the cancelled job's folder stayed on disk"
+
+
+# ─── a job stopped from the Trash (#748) ───
+
+
+async def test_a_run_stopped_from_the_trash_keeps_its_files(tmp_path):
+    """Only emptying the Trash deletes files, so Restore and Extract have the
+    source to work from."""
+    from app.core.models import JobCancelled
+    from app.pipeline import runner as _runner
+
+    job = _job(cancel_requested=True, stop_requested=True)
+    registry_register(job)
+    job_dir = tmp_path / job.id
+    job_dir.mkdir()
+    (job_dir / "source.wav").write_bytes(b"RIFF")
+
+    def cancelled(_job, _job_dir):
+        raise JobCancelled()
+
+    await _runner._run_async(job, job_dir, tmp_path, cancelled)
+
+    assert job.status == "stopped"
+    assert (job_dir / "source.wav").is_file()
+
+
+async def test_a_run_that_finishes_despite_a_late_trash_clears_the_flags(tmp_path):
+    """The trash arrived after the last cancel check, so the job finished. Left
+    set, the flags made every later vocal split or section run on it cancel
+    itself at once."""
+    from app.pipeline import runner as _runner
+
+    job = _job(cancel_requested=True, stop_requested=True)
+    registry_register(job)
+    job_dir = tmp_path / job.id
+    job_dir.mkdir()
+
+    await _runner._run_async(job, job_dir, tmp_path, lambda _job, _job_dir: None)
+
+    assert job.status == "done"
+    assert job.cancel_requested is False
+    assert job.stop_requested is False
diff --git a/tests/test_jobs_trash.py b/tests/test_jobs_trash.py
index 5b87793b..141fee67 100644
--- a/tests/test_jobs_trash.py
+++ b/tests/test_jobs_trash.py
@@ -14,6 +14,8 @@
 
 from __future__ import annotations
 
+from pathlib import Path
+
 import pytest
 from fastapi.testclient import TestClient
 
@@ -147,3 +149,149 @@ def test_a_registry_written_before_this_existed_still_loads() -> None:
     record = Job(id="666666666666", status="done", title="Old").to_record()
     del record["trashed_at"]
     assert Job.from_record(record).trashed_at is None
+
+
+# ── trashing a job that has not finished (#748) ─────────────────────────────
+#
+# Trashing used to leave an unfinished import running, hidden: the queue kept
+# working on a song the user had thrown away. The server now stops it, so the
+# phone and the desktop both get it. Its files stay: only emptying the Trash
+# deletes anything.
+
+
+class _FakeProc:
+    """Stands in for the registered subprocess: records the terminate."""
+
+    def __init__(self) -> None:
+        self.terminated = False
+
+    def poll(self):
+        return 0 if self.terminated else None
+
+    def terminate(self) -> None:
+        self.terminated = True
+
+
+def _queued_upload(job_id: str) -> tuple[Job, Path]:
+    from app.pipeline import jobqueue
+
+    job = Job(id=job_id, status="queued", title="Waiting", source_url="local:Waiting")
+    register(job)
+    jobqueue.enqueue(job.id, autostart=False)
+    job_dir = jobqueue.JOBS_DIR / job.id
+    job_dir.mkdir(parents=True)
+    (job_dir / "source.wav").write_bytes(b"RIFF")
+    return job, job_dir
+
+
+def test_trashing_a_queued_job_stops_it_and_keeps_its_files(client: TestClient) -> None:
+    from app.pipeline import jobqueue
+
+    job, job_dir = _queued_upload("888888888888")
+
+    assert client.post(f"/api/jobs/{job.id}/trash").status_code == 200
+
+    assert job.status == "stopped"
+    assert jobqueue.snapshot() == (None, []), "the queue would still run it"
+    assert (job_dir / "source.wav").is_file(), "only emptying the Trash deletes files"
+
+
+def test_a_plain_cancel_still_removes_a_queued_jobs_files(client: TestClient) -> None:
+    job, job_dir = _queued_upload("888888888887")
+
+    assert client.post(f"/api/jobs/{job.id}/cancel").status_code == 200
+
+    assert job.status == "cancelled"
+    assert not job_dir.exists(), "a waiting upload's source must not stay on disk"
+
+
+def test_emptying_the_trash_deletes_a_stopped_job(client: TestClient) -> None:
+    job, job_dir = _queued_upload("888888888886")
+    client.post(f"/api/jobs/{job.id}/trash")
+
+    assert client.delete(f"/api/jobs/{job.id}").status_code == 200
+
+    assert not job_dir.exists()
+
+
+def test_extract_queues_a_restored_stopped_job_again(client: TestClient) -> None:
+    from app.core.config import DEMUCS_MODEL
+    from app.pipeline import jobqueue
+
+    job, job_dir = _queued_upload("888888888885")
+    client.post(f"/api/jobs/{job.id}/trash")
+    (job_dir / DEMUCS_MODEL).mkdir()  # partial output from the stopped run
+    client.post(f"/api/jobs/{job.id}/restore")
+
+    res = client.post(f"/api/jobs/{job.id}/extract")
+
+    assert res.status_code == 200
+    assert res.json()["status"] == "queued"
+    assert job.cancel_requested is False and job.stop_requested is False
+    assert jobqueue.snapshot() == (None, [job.id])
+    assert (job_dir / "source.wav").is_file()
+    assert not (job_dir / DEMUCS_MODEL).exists(), "collect() would read stale stems"
+
+
+def test_restore_alone_does_not_queue_a_stopped_job(client: TestClient) -> None:
+    from app.pipeline import jobqueue
+
+    job, _ = _queued_upload("888888888884")
+    client.post(f"/api/jobs/{job.id}/trash")
+
+    assert client.post(f"/api/jobs/{job.id}/restore").status_code == 200
+
+    assert job.status == "stopped"
+    assert jobqueue.snapshot() == (None, [])
+
+
+def test_extract_refuses_a_job_still_in_the_trash(client: TestClient) -> None:
+    job, _ = _queued_upload("888888888883")
+    client.post(f"/api/jobs/{job.id}/trash")
+
+    assert client.post(f"/api/jobs/{job.id}/extract").status_code == 409
+    assert job.status == "stopped"
+
+
+def test_extract_refuses_a_job_that_is_not_stopped(client: TestClient) -> None:
+    job = _done("888888888882", "Finished")
+    assert client.post(f"/api/jobs/{job.id}/extract").status_code == 409
+    assert job.status == "done"
+
+
+def test_extract_rejects_a_malformed_or_unknown_id(client: TestClient) -> None:
+    # A traversal normalises away before routing (405), as for trash above.
+    for bad in ("../../etc/passwd", "not a job id", "%2e%2e%2f"):
+        resp = client.post(f"/api/jobs/{bad}/extract")
+        assert 400 <= resp.status_code < 500, (bad, resp.status_code)
+    assert client.post("/api/jobs/aaaaaaaaaaaa/extract").status_code == 404
+
+
+def test_trashing_the_running_job_stops_its_process(client: TestClient) -> None:
+    from app.core.registry import set_proc
+    from app.pipeline import jobqueue
+
+    job = Job(id="999999999990", status="analyzing", title="Running")
+    register(job)
+    jobqueue._set_running(job.id)
+    proc = _FakeProc()
+    set_proc(job.id, proc)
+    try:
+        assert client.post(f"/api/jobs/{job.id}/trash").status_code == 200
+    finally:
+        set_proc(job.id, None)
+        jobqueue._set_running(None)
+
+    assert job.cancel_requested is True
+    assert job.stop_requested is True, "it would settle as cancelled and lose its files"
+    assert proc.terminated, "the pipeline would have kept going in the Trash"
+    # Still in the Trash: the runner, not the endpoint, finalises a running job.
+    assert job.trashed_at is not None
+
+
+def test_trashing_a_finished_job_cancels_nothing(client: TestClient) -> None:
+    """A done job's files are what Restore brings back."""
+    job = _done("999999999991", "Finished")
+    client.post(f"/api/jobs/{job.id}/trash")
+    assert job.status == "done"
+    assert job.cancel_requested is False
diff --git a/tests/test_pipeline_analyze.py b/tests/test_pipeline_analyze.py
index 9b62b3da..75265e86 100644
--- a/tests/test_pipeline_analyze.py
+++ b/tests/test_pipeline_analyze.py
@@ -446,3 +446,79 @@ def test_a_silent_track_yields_no_key(job, jobs_dir):
     bpm, key = az.analyze(job, src)
     assert key is None or key.split()[0] in PITCHES
     assert bpm is None or bpm > 0
+
+
+# ── cancel (#748) ────────────────────────────────────────────────────
+
+
+def test_the_analyze_decode_is_registered_so_cancel_can_stop_it(job, jobs_dir, monkeypatch):
+    """subprocess.run() could not be reached by a cancel: a song trashed while
+    analysing stayed "Analyzing" until the decode and every step after it
+    finished (85 s in the report)."""
+    import numpy as np
+
+    src = jobs_dir / "x.wav"
+    src.write_bytes(b"RIFF")
+    calls = []
+
+    def fake_run_registered(job_arg, cmd, timeout, *, capture_stdout=False):
+        calls.append((job_arg, capture_stdout))
+        samples = np.zeros(22050, dtype=np.float32).tobytes()
+        return subprocess.CompletedProcess(cmd, 0, samples, b"")
+
+    monkeypatch.setattr(az, "run_registered", fake_run_registered)
+
+    result = az._load_audio_ffmpeg(src, job=job)
+
+    assert result is not None
+    assert calls == [(job, True)]
+
+
+def test_a_terminated_decode_reads_as_a_failure(job, jobs_dir, monkeypatch):
+    src = jobs_dir / "x.wav"
+    src.write_bytes(b"RIFF")
+    monkeypatch.setattr(
+        az,
+        "run_registered",
+        lambda _j, cmd, _t, **_k: subprocess.CompletedProcess(cmd, 1, b"", b""),
+    )
+    assert az._load_audio_ffmpeg(src, job=job) is None
+
+
+def test_a_cancel_during_the_decode_raises_rather_than_skipping(job, jobs_dir, monkeypatch):
+    """The cancel kills ffmpeg, which looks like a failed decode. Treated as
+    one, the job went on to separate a song the user had thrown away."""
+    from app.core.models import JobCancelled
+
+    pytest.importorskip("librosa")
+    src = jobs_dir / "x.wav"
+    src.write_bytes(b"RIFF")
+
+    def cancelled_decode(job_arg, cmd, _t, **_k):
+        job_arg.cancel_requested = True
+        return subprocess.CompletedProcess(cmd, 1, b"", b"")
+
+    monkeypatch.setattr(az, "run_registered", cancelled_decode)
+
+    with pytest.raises(JobCancelled):
+        az.analyze(job, src)
+
+
+def test_a_cancel_between_steps_is_not_swallowed(job, jobs_dir):
+    """The librosa steps cannot be interrupted, so the flag is checked between
+    them, and the stage's catch-all must let the cancel through."""
+    from app.core.models import JobCancelled
+
+    skip_without_ffmpeg()
+    librosa = pytest.importorskip("librosa")
+    src = _click_wav(jobs_dir / "c.wav", bpm=120.0, seconds=4.0)
+    real_hpss = librosa.effects.hpss
+
+    def hpss_then_cancel(y, *a, **k):
+        job.cancel_requested = True
+        return real_hpss(y, *a, **k)
+
+    with patch.object(librosa.effects, "hpss", hpss_then_cancel), pytest.raises(JobCancelled):
+        az.analyze(job, src)
+
+    assert job.bpm is None, "a cancelled analysis must not write its results"
diff --git a/tests/test_registry_persistence.py b/tests/test_registry_persistence.py
index fe4468d3..a37cded3 100644
--- a/tests/test_registry_persistence.py
+++ b/tests/test_registry_persistence.py
@@ -414,3 +414,50 @@ def test_records_without_a_position_still_restore_oldest_first(tmp_path: Path):
 
     restore_registry(tmp_path)
     assert _registry.take_pending_resume() == ["abcdef0000e2", "abcdef0000e1"]
+
+
+# ── a job trashed before the restart (#748) ──────────────────────────────────
+
+
+def test_a_trashed_interrupted_job_is_not_put_back_in_the_queue(tmp_path: Path):
+    """It came back as a Paused row offering to Start a song in the Trash."""
+    job = Job(id="abcdef0000f1", status="analyzing", title="Binned", trashed_at=1.0)
+    _jobs[job.id] = job
+    persist_registry(tmp_path)
+    (tmp_path / job.id).mkdir()
+    (tmp_path / job.id / "source.wav").write_bytes(b"RIFF")
+    _jobs.clear()
+
+    restore_registry(tmp_path)
+
+    assert _registry.take_pending_resume() == []
+    assert _jobs[job.id].status == "stopped"
+    assert (tmp_path / job.id / "source.wav").is_file(), "only emptying the Trash deletes files"
+
+
+def test_a_stopped_job_survives_a_restart_in_the_trash(tmp_path: Path):
+    """Not persisted, it would vanish from the Trash with its files orphaned."""
+    job = Job(id="abcdef0000f3", status="stopped", trashed_at=1.0)  # no title yet
+    _jobs[job.id] = job
+    persist_registry(tmp_path)
+    _jobs.clear()
+
+    restore_registry(tmp_path)
+
+    assert _jobs[job.id].status == "stopped"
+    assert _jobs[job.id].trashed_at == 1.0
+    assert _registry.take_pending_resume() == [], "only Extract may queue it again"
+
+
+def test_a_trashed_job_that_finished_before_the_crash_stays_in_the_trash(tmp_path: Path):
+    job = Job(id="abcdef0000f2", status="separating", title="Binned", trashed_at=1.0)
+    _jobs[job.id] = job
+    persist_registry(tmp_path)
+    _stems_dir(tmp_path, job.id)
+    _jobs.clear()
+
+    restore_registry(tmp_path)
+
+    assert _jobs[job.id].status == "done"
+    assert _jobs[job.id].trashed_at == 1.0, "a song the user binned would reappear"
+    assert _registry.take_pending_resume() == []
diff --git a/tests/test_video_status.py b/tests/test_video_status.py
index d89a71e5..5e1177f6 100644
--- a/tests/test_video_status.py
+++ b/tests/test_video_status.py
@@ -97,16 +97,16 @@ def _run_local_extract(tmp_path: Path, returncode: int, raises=None) -> Job:
     source = job_dir / "in.mp4"
     source.write_bytes(b"x")
 
-    # Stubs _run_registered_ffmpeg rather than subprocess.run: the extract goes
+    # Stubs run_registered rather than subprocess.run: the extract goes
     # through Popen + set_proc now, so cancel can reach it (#519).
     def fake_run(job_arg, cmd, timeout):
         if raises is not None:
             raise raises
         if returncode == 0:
             Path(cmd[-1]).write_bytes(b"fake mp4 payload")
-        return returncode, b""
+        return subprocess.CompletedProcess(cmd, returncode, b"", b"")
 
-    with patch.object(runner_mod, "_run_registered_ffmpeg", fake_run):
+    with patch.object(runner_mod, "run_registered", fake_run):
         runner_mod._extract_video_track(job, source, job_dir)
     return job