lumenfetch 2.1.0__tar.gz → 2.1.2__tar.gz

{lumenfetch-2.1.0 → lumenfetch-2.1.2}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.5
 Name: lumenfetch
-Version: 2.1.0
-Summary: YouTube downloader buat terminal - MP4 & MP3.
+Version: 2.1.2
+Summary: YouTube downloader for the terminal (MP4 & MP3).
 Project-URL: Homepage, https://github.com/nekonaru/lumenfetch
 Author: Nicolas Dwi Dharma
 License: MIT
@@ -376,6 +376,7 @@ Change it anytime via the `settings` command (`[1]`), absolute paths and `~` are
 | Naming template rejected in `settings` | Only `%(platform)s`, `%(title)s`, `%(year)s` are allowed - rejected automatically on typos so filenames never break |
 | `⚠️ Playlist with N videos` | Only the first video by default. Use `--playlist all` for all of them as indexed files |
 | `ffmpeg not found` | Install system ffmpeg first (lighter), bundled fallback is automatic. Check with `ffmpeg -version` |
+| `❌ YouTube needs a JavaScript runtime` | Install Deno (`winget install DenoLand.Deno`) or Node.js - required to solve YouTube signature challenges |
 
 ## 📝 Important Notes
 

{lumenfetch-2.1.0 → lumenfetch-2.1.2}/README.id.md

@@ -347,6 +347,7 @@ Ganti kapan saja lewat command `settings` (`[1]`), path absolut maupun `~` sama-
 | Batch download | Buat file teks (satu URL per baris, `#` = komentar), lalu `lumenfetch --batch daftar.txt --jobs 2` |
 | Resume download | Didukung via `continuedl` yt-dlp + retry backoff eksponensial (2s, 4s, 8s... max 30s). File parsial `.part` dilanjutkan, bukan diulang dari 0 |
 | `ffmpeg tidak ditemukan` | Install ffmpeg sistem dulu (lebih ringan), fallback bundled otomatis. Cek dengan `ffmpeg -version` |
+| `❌ YouTube butuh JavaScript runtime` | Install Deno (`winget install DenoLand.Deno`) atau Node.js - dibutuhkan untuk signature challenge YouTube |
 
 ## 📝 Catatan Penting
 

{lumenfetch-2.1.0 → lumenfetch-2.1.2}/README.md

@@ -343,6 +343,7 @@ Change it anytime via the `settings` command (`[1]`), absolute paths and `~` are
 | Naming template rejected in `settings` | Only `%(platform)s`, `%(title)s`, `%(year)s` are allowed - rejected automatically on typos so filenames never break |
 | `⚠️ Playlist with N videos` | Only the first video by default. Use `--playlist all` for all of them as indexed files |
 | `ffmpeg not found` | Install system ffmpeg first (lighter), bundled fallback is automatic. Check with `ffmpeg -version` |
+| `❌ YouTube needs a JavaScript runtime` | Install Deno (`winget install DenoLand.Deno`) or Node.js - required to solve YouTube signature challenges |
 
 ## 📝 Important Notes
 

{lumenfetch-2.1.0 → lumenfetch-2.1.2}/core/constants.py

@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-VERSION = "2.1.0"
+VERSION = "2.1.2"
 
 # --- Config ---
 HISTORY_LIMIT = 20

{lumenfetch-2.1.0 → lumenfetch-2.1.2}/core/detector.py

@@ -104,7 +104,14 @@ def _base_ydl_opts() -> dict:
         # Redirect raw yt-dlp noise (ERROR:/WARNING: lines) to the log file;
         # the terminal only shows friendly messages via rich.
         "logger": get_ydl_logger(),
-        "extractor_args": {"youtube": {"player_client": ["android", "web"]}},
+        # NOTE: do NOT force player_client here. An old override
+        # (["android", "web"]) dodged "Sign in to confirm you're not a bot"
+        # but now triggers YouTube's SABR-only experiment: only 1 progressive
+        # format served instead of ~46, so quality selection fails.
+        # yt-dlp's maintained defaults handle clients + fallbacks better.
+        # Signature challenges still need a JS runtime (deno is yt-dlp's
+        # default; also allow node/bun/quickjs if already installed).
+        "js_runtimes": {"node": {}, "deno": {}, "bun": {}, "quickjs": {}},
     }
 
 

{lumenfetch-2.1.0 → lumenfetch-2.1.2}/core/doctor.py

@@ -26,6 +26,7 @@ def run_all(config: dict | None = None) -> list[DoctorCheck]:
     checks: list[DoctorCheck] = [
         _check_python(),
         _check_ffmpeg(),
+        _check_js_runtime(),
         _check_curl_cffi(),
         _check_yt_dlp(),
         _check_self(),
@@ -61,6 +62,16 @@ def _check_ffmpeg() -> DoctorCheck:
         return DoctorCheck(name=t("doctor.ffmpeg"), ok=False, detail="-", hint=t("doctor.ffmpeg_hint"))
 
 
+def _check_js_runtime() -> DoctorCheck:
+    """At least one JS runtime (Deno/Node/Bun) must exist for YouTube challenges."""
+    import shutil
+
+    found = next((r for r in ("deno", "node", "bun", "quickjs") if shutil.which(r)), None)
+    if found:
+        return DoctorCheck(name=t("doctor.js"), ok=True, detail=found)
+    return DoctorCheck(name=t("doctor.js"), ok=False, detail="-", hint=t("doctor.js_hint"))
+
+
 def _check_curl_cffi() -> DoctorCheck:
     import importlib.util
 

{lumenfetch-2.1.0 → lumenfetch-2.1.2}/core/downloader.py

@@ -238,17 +238,41 @@ def download(
                         console.print(t("dl.retry", a=attempt, m=max_retry, d=delay))
                         time.sleep(delay)
                         continue
+                    if kind == "format" and attempt < max_retry:
+                        # SABR-only sessions come and go per request: a fresh
+                        # extraction may get full formats again. Same backoff.
+                        attempt += 1
+                        delay = backoff_delay(attempt)
+                        console.print(t("dl.retry", a=attempt, m=max_retry, d=delay))
+                        time.sleep(delay)
+                        continue
                     raise DownloadFailed(_friendly_message(kind)) from e
                 except Exception as e:  # noqa: BLE001
                     raise DownloadFailed(_friendly_message(_classify_error(e))) from e
-    except (DownloadCancelled, DownloadFailed):
-        _release_placeholder(dest, reserved)
+    except (DownloadCancelled, DownloadFailed) as e:
+        if isinstance(e, DownloadFailed):
+            salvaged = _salvage_media(dest, playlist_all)
+            if salvaged is not None:
+                path, size, count = salvaged
+                console.print(f"[yellow]{t('dl.pp_warning')}[/yellow]")
+                _cleanup_failed_dest(dest, reserved, playlist_all, keep={path})
+                return DownloadResult(
+                    filepath=path,
+                    size_bytes=size,
+                    elapsed_seconds=time.time() - start_time,
+                    file_count=count,
+                )
+        _cleanup_failed_dest(dest, reserved, playlist_all)
         raise
 
     elapsed = time.time() - start_time
     final_path, total_size, file_count = _resolve_final_path(dest, multi_item=playlist_all)
-    if file_count == 0:
-        _release_placeholder(dest, reserved)
+    if total_size == 0:
+        # yt-dlp reported success but left nothing (or an empty file):
+        # expired stream URLs typically end like this. Never report these
+        # as success, and don't leave 0-byte litter behind.
+        _cleanup_failed_dest(dest, reserved, playlist_all)
+        raise DownloadFailed(t("dl.empty_result"))
 
     if choice.output_kind == "audio" and playlist_all and file_count > 1:
         _write_m3u_playlist(dest)
@@ -256,6 +280,56 @@ def download(
     return DownloadResult(filepath=final_path, size_bytes=total_size, elapsed_seconds=elapsed, file_count=file_count)
 
 
+_IMAGE_EXTS = {".jpg", ".jpeg", ".png", ".webp"}
+
+
+def _salvage_media(dest: Path, multi_item: bool = False) -> tuple[Path, int, int] | None:
+    """Return (path, size, count) if a NON-EMPTY media file exists despite the failure.
+
+    Post-processing (e.g. thumbnail embed) must never nuke an otherwise good
+    download: a failed PP step on top of an intact video still counts.
+    """
+    matches = _find_result_files(dest, multi_item=multi_item)
+    good = [p for p in matches if p.exists() and p.suffix.lower() not in _IMAGE_EXTS]
+    good = [p for p in good if _safe_size(p) > 0]
+    if not good:
+        return None
+    total = sum(_safe_size(p) for p in good)
+    return good[0], total, len(good)
+
+
+def _safe_size(p: Path) -> int:
+    try:
+        return p.stat().st_size
+    except OSError:
+        return 0
+
+
+def _cleanup_failed_dest(dest: Path, reserved: bool, multi_item: bool = False, keep: frozenset | set = frozenset()) -> None:
+    """Remove our placeholder, 0-byte results, and thumbnail leftovers of a failed download.
+
+    Never touches non-empty media files outside `keep`... in fact never
+    touches non-empty media at all: only our own empty placeholder, 0-byte
+    stem files, and stem thumbnail litter from crashed runs.
+    """
+    _release_placeholder(dest, reserved)
+    try:
+        if multi_item:
+            candidates = find_indexed_files(dest)
+        else:
+            candidates = [p for p in _iter_dir_files(dest.parent) if p.is_file() and p.stem == dest.stem]
+        for p in candidates:
+            if p in keep:
+                continue
+            try:
+                if p.suffix.lower() in _IMAGE_EXTS or _safe_size(p) == 0:
+                    p.unlink()
+            except OSError:
+                pass
+    except OSError:
+        pass
+
+
 def _write_m3u_playlist(dest: Path) -> Path | None:
     """Write a `.m3u` playlist next to audio `--playlist all` results. Best effort."""
     try:
@@ -331,8 +405,11 @@ def _build_ydl_opts(
         "fragment_retries": 3,
         "continuedl": True,  # resume partial files (.part)
         "skip_unavailable_fragments": False,
+        # Same as detector._base_ydl_opts: a JS runtime is needed for signature challenges.
+        "js_runtimes": {"node": {}, "deno": {}, "bun": {}, "quickjs": {}},
         "noplaylist": not playlist_all,
-        "extractor_args": {"youtube": {"player_client": ["android", "web"]}},
+        # No forced player_client (see detector._base_ydl_opts): yt-dlp
+        # defaults survive YouTube's SABR-only sessions much better.
     }
 
     if force_single_item:

{lumenfetch-2.1.0 → lumenfetch-2.1.2}/core/errors.py

@@ -34,6 +34,7 @@ ERROR_KIND_REMOVED = "removed"
 ERROR_KIND_UNSUPPORTED = "unsupported"
 ERROR_KIND_BLOCKED = "blocked"
 ERROR_KIND_COOKIES = "cookies"
+ERROR_KIND_JSRUNTIME = "jsruntime"
 ERROR_KIND_UNKNOWN = "unknown"
 
 _KIND_TO_KEY = {
@@ -46,6 +47,7 @@ _KIND_TO_KEY = {
     ERROR_KIND_UNSUPPORTED: "err.unsupported",
     ERROR_KIND_BLOCKED: "err.blocked",
     ERROR_KIND_COOKIES: "err.cookies",
+    ERROR_KIND_JSRUNTIME: "err.jsruntime",
     ERROR_KIND_UNKNOWN: "err.unknown",
 }
 
@@ -63,6 +65,10 @@ def classify_error(exc: Exception) -> str:
         # Encrypted cookies cannot be decrypted (yt-dlp #10927, common on
         # Edge/Chrome for Windows) - likewise: not a broken URL, fall back without cookies.
         return ERROR_KIND_COOKIES
+    if "javascript runtime" in msg or "js runtime" in msg:
+        # Modern yt-dlp needs Deno/Node/Bun to solve YouTube signature
+        # challenges - without one, videos fail as "unavailable".
+        return ERROR_KIND_JSRUNTIME
     if "unexpected response from webpage request" in msg or "confirm you are on the latest version" in msg:
         # Bot-check challenge that only passes with impersonation + cookies,
         # not a broken URL.

{lumenfetch-2.1.0 → lumenfetch-2.1.2}/core/i18n.py

@@ -126,7 +126,7 @@ STRINGS: dict[str, dict[str, str]] = {
         "eta.hour": "~{n} hours",
         "err.connection": "❌ Connection trouble, try again",
         "err.private": "❌ This content is private / unavailable - try enabling Browser Cookies in settings",
-        "err.format": "❌ Format not available for this content",
+        "err.format": "❌ No matching format available right now - please retry",
         "err.disk": "❌ Not enough disk space",
         "err.rate_limit": "❌ Too many requests to this platform - wait a bit then retry",
         "err.removed": "❌ This content was deleted / is no longer available",
@@ -140,10 +140,16 @@ STRINGS: dict[str, dict[str, str]] = {
             "❌ Failed to read browser cookies - close the browser completely "
             "(check Task Manager), then try again"
         ),
+        "err.jsruntime": (
+            "❌ YouTube needs a JavaScript runtime (Deno or Node.js) - install one, "
+            "e.g. winget install DenoLand.Deno, then retry"
+        ),
         "err.unknown": "❌ Download error occurred",
         "err.unknown_detect": "Not a valid YouTube URL or unsupported",
         "dl.cookie_retry": "continuing without cookies...",
         "dl.retry": "🔄 Retry {a}/{m} in {d:.0f}s...",
+        "dl.pp_warning": "⚠️ Post-processing failed (e.g. thumbnail embed) - but the video file itself is fine and kept.",
+        "dl.empty_result": "❌ Download produced no data (stream links may have expired) - please retry",
         "doctor.title": "🩺 Lumenfetch Doctor",
         "doctor.col_check": "Check",
         "doctor.col_result": "Result",
@@ -155,6 +161,8 @@ STRINGS: dict[str, dict[str, str]] = {
         "doctor.ffmpeg_bundled": "bundled (static-ffmpeg)",
         "doctor.ffmpeg_hint": "Install system ffmpeg or pip install static-ffmpeg",
         "doctor.curl": "curl_cffi (bot-check bypass)",
+        "doctor.js": "JS runtime (Deno/Node for challenges)",
+        "doctor.js_hint": "install Deno (winget install DenoLand.Deno) or Node.js",
         "doctor.installed": "installed",
         "doctor.missing": "missing",
         "doctor.curl_hint": "pip install curl_cffi",
@@ -288,7 +296,7 @@ STRINGS: dict[str, dict[str, str]] = {
         "eta.hour": "~{n} jam",
         "err.connection": "❌ Koneksi internet bermasalah, coba lagi",
         "err.private": "❌ Konten ini private / tidak bisa diakses - coba aktifkan Cookies dari Browser di settings",
-        "err.format": "❌ Format tidak tersedia untuk konten ini",
+        "err.format": "❌ Format tidak tersedia saat ini - coba lagi",
         "err.disk": "❌ Tidak cukup ruang disk",
         "err.rate_limit": "❌ Terlalu banyak request ke platform ini - tunggu sebentar lalu coba lagi",
         "err.removed": "❌ Konten ini sudah dihapus / tidak lagi tersedia",
@@ -302,10 +310,16 @@ STRINGS: dict[str, dict[str, str]] = {
             "❌ Gagal membaca cookies dari browser - tutup browser-nya sampai "
             "benar-benar tertutup (cek Task Manager), lalu coba lagi"
         ),
+        "err.jsruntime": (
+            "❌ YouTube butuh JavaScript runtime (Deno atau Node.js) - install salah satu, "
+            "mis. winget install DenoLand.Deno, lalu coba lagi"
+        ),
         "err.unknown": "❌ Terjadi kesalahan saat download",
         "err.unknown_detect": "URL bukan link YouTube yang valid atau tidak didukung",
         "dl.cookie_retry": "lanjut tanpa cookies...",
         "dl.retry": "🔄 Retry {a}/{m} dalam {d:.0f}s...",
+        "dl.pp_warning": "⚠️ Post-processing gagal (mis. embed thumbnail) - tapi file videonya utuh dan disimpan.",
+        "dl.empty_result": "❌ Download tidak menghasilkan data (link stream mungkin kedaluwarsa) - coba lagi",
         "doctor.title": "🩺 Lumenfetch Doctor",
         "doctor.col_check": "Cek",
         "doctor.col_result": "Hasil",
@@ -317,6 +331,8 @@ STRINGS: dict[str, dict[str, str]] = {
         "doctor.ffmpeg_bundled": "bundled (static-ffmpeg)",
         "doctor.ffmpeg_hint": "Install ffmpeg sistem atau pip install static-ffmpeg",
         "doctor.curl": "curl_cffi (lolos bot-check)",
+        "doctor.js": "JS runtime (Deno/Node untuk challenge)",
+        "doctor.js_hint": "install Deno (winget install DenoLand.Deno) atau Node.js",
         "doctor.installed": "terinstall",
         "doctor.missing": "hilang",
         "doctor.curl_hint": "pip install curl_cffi",

{lumenfetch-2.1.0 → lumenfetch-2.1.2}/pyproject.toml

@@ -4,8 +4,8 @@ build-backend = "hatchling.build"
 
 [project]
 name = "lumenfetch"
-version = "2.1.0"
-description = "YouTube downloader buat terminal - MP4 & MP3."
+version = "2.1.2"
+description = "YouTube downloader for the terminal (MP4 & MP3)."
 readme = "README.md"
 requires-python = ">=3.9"
 license = { text = "MIT" }

{lumenfetch-2.1.0 → lumenfetch-2.1.2}/tests/test_downloader.py

@@ -153,6 +153,7 @@ def test_download_forces_single_item_for_pure_playlist_video(tmp_path, monkeypat
     class FakeYDL:
         def __init__(self, opts):
             captured_opts.update(opts)
+            self.opts = opts
 
         def __enter__(self):
             return self
@@ -161,7 +162,10 @@ def test_download_forces_single_item_for_pure_playlist_video(tmp_path, monkeypat
             return False
 
         def download(self, urls):
-            (tmp_path / "Judul-Playlist_2026.mp4").write_bytes(b"video pertama doang")
+            from pathlib import Path as _P
+
+            base = self.opts["outtmpl"].rsplit(".", 1)[0]
+            _P(f"{base}.mp4").write_bytes(b"video pertama doang")
 
     monkeypatch.setattr(downloader.yt_dlp, "YoutubeDL", FakeYDL)
 
@@ -212,7 +216,6 @@ def test_download_playlist_all_finds_indexed_files(tmp_path, monkeypatch):
 
 def test_download_retries_connection_with_backoff(tmp_path, monkeypatch):
     attempts = []
-
     class FakeYDL:
         def __init__(self, opts):
             self.opts = opts
@@ -264,7 +267,10 @@ def test_download_retries_without_cookies_when_cookie_copy_fails(tmp_path, monke
             calls.append("cookiesfrombrowser" in self.opts)
             if "cookiesfrombrowser" in self.opts:
                 raise downloader.yt_dlp.utils.DownloadError("Could not copy Chrome cookie database")
-            (tmp_path / "Judul_2026.mp4").write_bytes(b"x")
+            from pathlib import Path as _P
+
+            base = self.opts["outtmpl"].rsplit(".", 1)[0]
+            _P(f"{base}.mp4").write_bytes(b"x")
 
     monkeypatch.setattr(downloader.yt_dlp, "YoutubeDL", FakeYDL)
 
@@ -431,3 +437,124 @@ def test_failed_download_cleans_own_placeholder(tmp_path, monkeypatch):
 
     leftovers = [p for p in tmp_path.iterdir() if p.is_file()]
     assert leftovers == []
+
+
+def test_empty_result_is_failure_not_success(tmp_path, monkeypatch):
+    """yt-dlp success with a 0-byte file (expired stream URLs) must fail loudly."""
+
+    class FakeYDL:
+        def __init__(self, opts):
+            self.opts = opts
+
+        def __enter__(self):
+            return self
+
+        def __exit__(self, *args):
+            return False
+
+        def download(self, urls):
+            base = self.opts["outtmpl"].rsplit(".", 1)[0]
+            from pathlib import Path as _P
+
+            _P(f"{base}.mp4").write_bytes(b"")  # 0 bytes, like expired-URL runs
+
+    monkeypatch.setattr(downloader.yt_dlp, "YoutubeDL", FakeYDL)
+
+    class FakeContent:
+        url = "https://www.youtube.com/watch?v=abc"
+        platform = "YouTube"
+        title = "Judul Kosong"
+        entries = []
+
+    choice = DownloadChoice(output_kind="video", quality="Best", fmt="mp4")
+    with pytest.raises(downloader.DownloadFailed):
+        downloader.download(FakeContent(), choice, tmp_path, "%(title)s")
+
+    assert [p for p in tmp_path.iterdir() if p.is_file()] == []
+
+
+def test_postprocessor_crash_salvages_good_video(tmp_path, monkeypatch, capsys):
+    """EmbedThumbnail-style crash on top of an intact video still counts as success."""
+
+    class FakeYDL:
+        def __init__(self, opts):
+            self.opts = opts
+
+        def __enter__(self):
+            return self
+
+        def __exit__(self, *args):
+            return False
+
+        def download(self, urls):
+            base = self.opts["outtmpl"].rsplit(".", 1)[0]
+            from pathlib import Path as _P
+
+            _P(f"{base}.mp4").write_bytes(b"good-video-bytes")
+            _P(f"{base}.png").write_bytes(b"thumbnail-litter")
+            raise downloader.yt_dlp.utils.DownloadError("EmbedThumbnailPP: KeyError streams")
+
+    monkeypatch.setattr(downloader.yt_dlp, "YoutubeDL", FakeYDL)
+
+    class FakeContent:
+        url = "https://www.youtube.com/watch?v=abc"
+        platform = "YouTube"
+        title = "Judul Bagus"
+        entries = []
+
+    choice = DownloadChoice(output_kind="video", quality="Best", fmt="mp4")
+    result = downloader.download(FakeContent(), choice, tmp_path, "%(title)s")
+
+    assert result.file_count == 1
+    assert result.size_bytes == len(b"good-video-bytes")
+    assert result.filepath.exists()
+    # thumbnail litter cleaned, video kept
+    assert not list(tmp_path.glob("*.png"))
+
+
+def test_no_forced_player_client(tmp_path):
+    from core import detector
+    from core.options import DownloadChoice as _DC
+
+    assert "extractor_args" not in detector._base_ydl_opts()
+    choice = _DC(output_kind="video", quality="Best", fmt="mp4")
+    assert "extractor_args" not in downloader._build_ydl_opts(choice, tmp_path / "v.mp4")
+
+
+def test_download_retries_transient_format_errors(tmp_path, monkeypatch):
+    """SABR-only sessions are transient: a fresh extraction may get full formats."""
+    attempts = []
+
+    class FakeYDL:
+        def __init__(self, opts):
+            self.opts = opts
+
+        def __enter__(self):
+            return self
+
+        def __exit__(self, *args):
+            return False
+
+        def download(self, urls):
+            attempts.append(1)
+            if len(attempts) == 1:
+                raise downloader.yt_dlp.utils.DownloadError("Requested format is not available")
+            base = self.opts["outtmpl"].rsplit(".", 1)[0]
+            from pathlib import Path as _P
+
+            _P(f"{base}.mp4").write_bytes(b"recovered")
+
+    monkeypatch.setattr(downloader.yt_dlp, "YoutubeDL", FakeYDL)
+
+    class FakeContent:
+        url = "https://www.youtube.com/watch?v=abc"
+        platform = "YouTube"
+        title = "Judul"
+        entries = []
+
+    choice = DownloadChoice(output_kind="video", quality="Best", fmt="mp4")
+    result = downloader.download(FakeContent(), choice, tmp_path, "%(title)s", max_retry=2)
+
+    assert len(attempts) == 2
+    assert result.file_count == 1
+    assert result.size_bytes == len(b"recovered")

{lumenfetch-2.1.0 → lumenfetch-2.1.2}/tests/test_features.py

@@ -198,6 +198,36 @@ def test_classify_dpapi_failure_as_cookies():
     assert classify_error(Exception("failed to load cookies")) == ERROR_KIND_COOKIES
 
 
+def test_classify_missing_js_runtime():
+    from core.errors import ERROR_KIND_JSRUNTIME, classify_error, friendly_message
+
+    err = Exception("No supported JavaScript runtime could be found. Only deno is enabled by default")
+    assert classify_error(err) == ERROR_KIND_JSRUNTIME
+    assert "deno" in friendly_message(ERROR_KIND_JSRUNTIME).lower()
+
+
+def test_doctor_js_runtime_check(monkeypatch):
+    import shutil
+
+    from core import doctor
+
+    monkeypatch.setattr(shutil, "which", lambda name: "/usr/bin/node" if name == "node" else None)
+    check = doctor._check_js_runtime()
+    assert check.ok is True
+    assert check.detail == "node"
+    monkeypatch.setattr(shutil, "which", lambda name: None)
+    assert doctor._check_js_runtime().ok is False
+
+
+def test_build_opts_enable_js_runtimes(tmp_path):
+    from core import downloader
+    from core.options import DownloadChoice
+
+    choice = DownloadChoice(output_kind="video", quality="Best", fmt="mp4")
+    opts = downloader._build_ydl_opts(choice, tmp_path / "v.mp4")
+    assert "node" in opts["js_runtimes"]
+
+
 def test_resolve_cookie_file(tmp_path):
     assert utils.resolve_cookie_file(None) is None
     assert utils.resolve_cookie_file("") is None
@@ -327,7 +357,7 @@ def test_doctor_all_checks_structure():
 
     checks = doctor.run_all({})
     names = [c.name for c in checks]
-    assert len(checks) == 8
+    assert len(checks) == 9
     assert all(isinstance(c.ok, bool) for c in checks)
     assert any("ffmpeg" in n.lower() for n in names)