discstation 0.1.18 → 0.1.21

package/src/discstation_burn.py

@@ -520,6 +520,8 @@ status_sink = None
 
 def send(ser, msg):
     global _serial_write_failed
+    if os.environ.get("DISCSTATION_DEBUG_SERIAL"):
+        print(f"[{time.time():.3f}] SEND {msg!r}", flush=True)
     if status_sink is not None:
         try:
             status_sink(msg)
@@ -719,7 +721,7 @@ def get_local_video_info(path):
     return {"title": stem, "duration": dur}
 
 
-def get_video_info(source):
+def get_video_info(source, ser=None):
     p = Path(source)
     if p.is_dir():
         videos = find_video_files(source)
@@ -731,11 +733,25 @@ def get_video_info(source):
         return get_local_video_info(source)
     errors = []
     for player_client in YTDLP_PLAYER_CLIENTS or (None,):
-        r = subprocess.run(
-            [*ytdlp_base_args(player_client), '--dump-single-json', '--skip-download', source],
-            capture_output=True,
-            text=True,
-        )
+        # This yt-dlp metadata fetch can take a while (retries, slow network) -
+        # without a PING during the wait, the ESP32's 30s silence watchdog
+        # flips the OLED to "disconnected" while the host is still alive and
+        # just blocked on subprocess.run. Same keepalive download() uses.
+        stop_ping, pt = _start_keepalive(ser) if ser else (None, None)
+        try:
+            r = subprocess.run(
+                [*ytdlp_base_args(player_client), '--dump-single-json', '--skip-download', source],
+                capture_output=True,
+                text=True,
+                timeout=90,
+            )
+        except subprocess.TimeoutExpired:
+            errors.append(f"{player_client or 'default'} client timed out")
+            continue
+        finally:
+            if stop_ping:
+                stop_ping.set()
+                pt.join(timeout=1)
         if r.returncode != 0:
             errors.append(r.stderr.strip() or f"{player_client or 'default'} client failed")
             continue
@@ -1099,7 +1115,11 @@ def author(ser, mpg, job_dir, aspect="4:3"):
     send(ser, "PROGRESS:Building IFO/VOB")
     dvd_dir = job_dir / "dvd_out"
     dvd_dir.mkdir(parents=True, exist_ok=True)
-    xml = f"""<dvdauthor dest={chr(34) + str(dvd_dir) + chr(34)} format="pal">
+    # Format is conveyed via the VIDEO_FORMAT env var below, not this XML
+    # attribute - some dvdauthor builds (the Windows one) reject a `format`
+    # attribute on <dvdauthor> outright ("Cannot match attribute 'format'"),
+    # which would fail authoring on every single burn.
+    xml = f"""<dvdauthor dest={chr(34) + str(dvd_dir) + chr(34)}>
   <vmgm />
   <titleset>
     <titles>
@@ -1323,6 +1343,14 @@ def burn(ser, dvd_dir, disc_label, speed=None, is_dual_layer=False):
         try:
             discstation_host.build_data_image([dvd_dir], image_path, disc_label, video=True)
             burn_iso(ser, image_path, speed, is_dual_layer)
+        except (RuntimeError, FileNotFoundError) as e:
+            if discstation_host.system_name() != "windows":
+                raise
+            # no xorriso -> burn the VIDEO_TS tree as a plain data disc (plays on
+            # modern players; not guaranteed on old set-tops).
+            print(f"xorriso unavailable ({e}); burning VIDEO_TS as a data disc")
+            _run_windows_burn(ser, "burn-data.ps1", disc_device(), str(dvd_dir),
+                              disc_label, re.sub(r"\D", "", speed or ""))
         finally:
             image_path.unlink(missing_ok=True)
         return
@@ -1350,6 +1378,13 @@ def burn_data(ser, source_paths, disc_label, speed=None, is_dual_layer=False):
         try:
             discstation_host.build_data_image(source_paths, image_path, disc_label)
             burn_iso(ser, image_path, speed, is_dual_layer)
+        except (RuntimeError, FileNotFoundError) as e:
+            if discstation_host.system_name() != "windows":
+                raise
+            print(f"xorriso unavailable ({e}); using IMAPI2 data burn")
+            src = str(source_paths[0]) if len(source_paths) == 1 else _stage_dir(source_paths)
+            _run_windows_burn(ser, "burn-data.ps1", disc_device(), src, disc_label,
+                              re.sub(r"\D", "", speed or ""))
         finally:
             image_path.unlink(missing_ok=True)
         return
@@ -1464,6 +1499,17 @@ def burn_audio_cd(ser, audio_files, disc_label, speed=None):
           f"{len(track_meta)} track titles")
     send(ser, "PROGRESS:35%")
 
+    if discstation_host.system_name() == "windows":
+        # No cdrdao on Windows — burn the prepared WAVs via IMAPI2 Track-At-Once.
+        send(ser, "STATUS:Burning audio CD...")
+        _run_windows_burn(ser, "burn-audio.ps1", disc_device(), str(tmp_dir),
+                          re.sub(r"\D", "", (speed or DISC_SPEED) or ""))
+        for w in tmp_dir.glob("*.wav"):
+            w.unlink(missing_ok=True)
+        toc_path.unlink(missing_ok=True)
+        safe_send(ser, "DONE:Audio CD complete!")
+        return
+
     send(ser, "STATUS:Burning audio CD...")
     # The cooked generic-mmc writer does NOT lay down the CD-TEXT lead-in on most
     # ATAPI drives; the raw writer does. Override with DISCSTATION_CDRDAO_DRIVER
@@ -1524,11 +1570,124 @@ def burn_audio_cd(ser, audio_files, disc_label, speed=None):
         print(f"CD eject skipped: {e}")
 
 
+def _stage_dir(paths):
+    """Copy several loose paths into one temp folder (IMAPI2 burn-data takes one)."""
+    staging = WORK / f"stage_{time.strftime('%Y%m%d_%H%M%S')}"
+    staging.mkdir(parents=True, exist_ok=True)
+    for p in paths:
+        p = Path(p)
+        dest = staging / p.name
+        if p.is_dir():
+            shutil.copytree(p, dest, dirs_exist_ok=True)
+        else:
+            shutil.copy2(p, dest)
+    return str(staging)
+
+
+def _estimate_burn_seconds(source):
+    """Rough total write time for the synthetic progress fallback below,
+    assuming a ~4x DVD write speed (5.54MB/s) - real speed varies by drive
+    and media, so this is a ceiling to tune if it drifts, not a promise."""
+    p = Path(source)
+    size = tree_size(p) if p.is_dir() else (p.stat().st_size if p.is_file() else 0)
+    return max(size / (5.54 * 1024 * 1024), 1.0)
+
+
+def _run_windows_burn(ser, script, *script_args):
+    """Run a src/win/<script> IMAPI2 burn helper, streaming its PROGRESS:<pct>
+    lines to the ESP32. Raises RuntimeError on a non-zero exit.
+
+    IMAPI2's progress event doesn't reliably reach PowerShell on every
+    setup (COM event dispatch needs the calling thread to pump messages,
+    which it can't do while blocked inside the synchronous native Write()
+    call) - so real PROGRESS lines may never arrive until the very end.
+    While waiting, synthesize a smoothly-climbing estimate from elapsed
+    time vs. the source size at a conservative write speed, capped at 95%
+    until the process actually exits; real PROGRESS lines (from scripts
+    where the event does work, e.g. burn-audio.ps1's per-track updates)
+    still take priority whenever they show up.
+    """
+    send(ser, "STATUS:Burning...")
+    send(ser, "PROGRESS:0%")
+    est_total = _estimate_burn_seconds(script_args[1]) if len(script_args) > 1 else None
+    cmd, kwargs = discstation_host.ps_cmd(script, *script_args)
+    proc = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True, **kwargs)
+
+    lines = Queue()
+    finished = object()
+
+    def read_output():
+        try:
+            for line in proc.stdout:
+                lines.put(line.rstrip("\r\n"))
+        finally:
+            lines.put(finished)
+
+    reader = threading.Thread(target=read_output, daemon=True)
+    reader.start()
+
+    out_lines, last_pct, last_real_progress, start = [], -1, 0.0, time.time()
+    last_ping, output_done = time.time(), False
+    try:
+        while proc.poll() is None or not output_done:
+            if time.time() - last_ping >= 5:
+                last_ping = time.time()
+                send(ser, "PING")
+            if check_cancel(ser):
+                stop_process(proc)
+                return
+            try:
+                line = lines.get(timeout=0.2)
+            except Empty:
+                line = None
+            if line is finished:
+                output_done = True
+            elif line is not None:
+                out_lines.append(line)
+                m = re.search(r"PROGRESS:(-?\d+)", line)
+                if m:
+                    pct = int(m.group(1))
+                    if 0 <= pct <= 100 and pct != last_pct:
+                        last_pct, last_real_progress = pct, time.time()
+                        send(ser, f"PROGRESS:{min(pct, 99)}%")
+                    continue
+            # No fresh real progress recently - IMAPI2's Write() blocks the
+            # PowerShell thread the whole time, so its Update event often
+            # never gets dispatched until the call returns. Estimate from
+            # elapsed time instead of leaving the OLED stuck at 0%.
+            if est_total and time.time() - last_real_progress > 3:
+                est_pct = int(min(95, (time.time() - start) / est_total * 100))
+                if est_pct > last_pct:
+                    last_pct = est_pct
+                    send(ser, f"PROGRESS:{est_pct}%")
+        reader.join(timeout=1)
+    except (KeyboardInterrupt, SystemExit):
+        stop_process(proc)
+        raise
+    if proc.wait() != 0:
+        detail = next((l for l in reversed(out_lines) if l.strip()), "burn failed")
+        raise RuntimeError(f"Disc burn failed: {detail[:150]}")
+    safe_send(ser, "PROGRESS:100%")
+
+
 def burn_iso(ser, iso_path, speed=None, is_dual_layer=False):
     """Burn a pre-built ISO directly to disc — no filesystem building."""
     if discstation_host.system_name() == "darwin":
         _run_hdiutil_burn(ser, iso_path)
         return
+    if discstation_host.system_name() == "windows":
+        drive = disc_device()
+        spd = re.sub(r"\D", "", speed or "")
+        try:
+            _run_windows_burn(ser, "burn-image.ps1", drive, str(iso_path), spd)
+        except RuntimeError:
+            isoburn = shutil.which("isoburn") or os.path.join(
+                os.environ.get("SystemRoot", r"C:\Windows"), "System32", "isoburn.exe")
+            send(ser, "STATUS:Burning image (isoburn)...")
+            if subprocess.run([isoburn, "/Q", drive, str(iso_path)]).returncode != 0:
+                raise
+            safe_send(ser, "PROGRESS:100%")
+        return
     if discstation_host.system_name() != "linux":
         send(ser, "STATUS:Burning image...")
         _run_growisofs(ser, discstation_host.iso_burn_command(disc_device(), iso_path), iso_path.parent / "discstation-burn.log")
@@ -1636,7 +1795,7 @@ def main():
         print("Connected to DiscStation")
         print("Running preflight...")
         send(ser, "STATUS:Preflight...")
-        info = get_video_info(url)
+        info = get_video_info(url, ser)
         title = info["title"]
         duration = info["duration"]
         duration_line, fit_line, can_fit = preflight_lines(duration)

package/src/discstation_host.py

@@ -9,6 +9,8 @@ import platform
 import re
 import shutil
 import subprocess
+import sys
+import threading
 from pathlib import Path
 
 from serial.tools import list_ports
@@ -98,6 +100,64 @@ def _mac_optical_device():
 
 _last_disc_device = None
 
+# --- Windows: IMAPI2 / WMI probes via bundled PowerShell helpers ---------------
+_WIN_DIR = Path(__file__).resolve().parent / "win"
+_win_info_cache = (0.0, None)
+_win_info_lock = threading.Lock()
+
+
+def ps_cmd(script_name, *args):
+    """Build a `powershell -File src/win/<script_name> <args>` argv, plus the
+    Popen/run kwargs that suppress the console window. The host runs as
+    pythonw.exe (no console); without CREATE_NO_WINDOW, Windows pops a
+    brand-new visible console for every one of these - and disc detection
+    polls every ~1.5s, so it would flash constantly."""
+    cmd = ["powershell", "-NoProfile", "-NonInteractive", "-ExecutionPolicy", "Bypass",
+           "-File", str(_WIN_DIR / script_name), *[str(a) for a in args]]
+    kwargs = {"creationflags": subprocess.CREATE_NO_WINDOW} if hasattr(subprocess, "CREATE_NO_WINDOW") else {}
+    return cmd, kwargs
+
+
+def _run_ps(script_name, *args, timeout=25):
+    """Run src/win/<script_name> and return (returncode, stdout, stderr)."""
+    cmd, kwargs = ps_cmd(script_name, *args)
+    try:
+        r = subprocess.run(cmd, capture_output=True, text=True, timeout=timeout, **kwargs)
+        return r.returncode, r.stdout, r.stderr
+    except (OSError, subprocess.TimeoutExpired):
+        return 1, "", ""
+
+
+def _win_disc_info(force=False):
+    """Cached (~2s) dict from src/win/disc-info.ps1, or {} on failure.
+
+    Locked: disc-info.ps1's IMAPI2 calls appear to serialize on the physical
+    drive, so a burst of concurrent callers (multiple web UI tabs, the HTTP
+    /disc-info endpoint racing station_loop's own poll) each missing the
+    cache at once used to spawn a pile of concurrent powershell.exe
+    processes that queued up behind each other and blew past the timeout -
+    reporting a false "no disc". One in-flight refresh, shared by whoever's
+    waiting, instead of one per caller."""
+    import json as _json
+    import time
+    global _win_info_cache
+    with _win_info_lock:
+        ts, cached = _win_info_cache
+        if not force and cached is not None and time.time() - ts < 2.0:
+            return cached
+        override = os.environ.get("DISC_DEVICE") or os.environ.get("DVD_DEVICE") or ""
+        rc, out, _ = _run_ps("disc-info.ps1", *([override] if override else []), timeout=20)
+        info = {}
+        for line in out.splitlines():
+            line = line.strip()
+            if line.startswith("{"):
+                try:
+                    info = _json.loads(line)
+                except ValueError:
+                    pass
+        _win_info_cache = (time.time(), info)
+        return info
+
 
 def disc_device():
     global _last_disc_device
@@ -140,13 +200,22 @@ def disc_device():
             if "/dev/disk" in line and ("CD" in line or "DVD" in line or "optical" in line.lower()):
                 return line.strip().split()[0]
     elif system == "windows":
-        raise RuntimeError("Set DISC_DEVICE to the optical drive letter on Windows")
+        info = _win_disc_info()
+        if info.get("drive"):
+            return info["drive"]
+        if override:
+            return override
     raise FileNotFoundError("No optical disc drive found; set DISC_DEVICE explicitly")
 
 
 def drive_status():
     """Non-Linux equivalent of the CDROM_DRIVE_STATUS ioctl.
-    Returns 'disc' | 'no_disc' | 'unknown'. macOS: parse `drutil status`."""
+    Returns 'disc' | 'no_disc' | 'unknown'. macOS: `drutil status`; Windows: IMAPI2/WMI."""
+    if system_name() == "windows":
+        info = _win_disc_info()
+        if not info:
+            return "unknown"
+        return "disc" if info.get("media_loaded") else "no_disc"
     if system_name() != "darwin":
         return "unknown"
     try:
@@ -244,10 +313,35 @@ def media_properties(device):
             props["ID_CDROM_MEDIA_DVD_PLUS_R"] = "1"
         _tag_rewritable(props, optical)
         return props
+    if system_name() == "windows":
+        info = _win_disc_info()
+        if not info.get("media_loaded"):
+            return {}
+        props = {"ID_CDROM": "1", "ID_CDROM_MEDIA": "1"}
+        if info.get("label"):
+            props["ID_FS_LABEL"] = info["label"]
+        if info.get("fs") in ("udf", "iso9660"):
+            props["ID_FS_TYPE"] = info["fs"]
+        mtype = (info.get("media_type") or "").lower()
+        if mtype == "audio_cd" or (not info.get("fs") and not info.get("blank") and mtype.startswith("cd")):
+            props["ID_CDROM_MEDIA_TYPE"] = "audio"
+        elif mtype.startswith("dvd") or mtype.startswith("bd"):
+            props["ID_CDROM_MEDIA_TYPE"] = "dvd"
+        if info.get("blank"):
+            props["ID_CDROM_MEDIA_STATE"] = "blank"
+        if "dvd+r dl" in mtype or "dvd-r dl" in mtype:
+            props["ID_CDROM_MEDIA_DVD_PLUS_R_DL"] = "1"
+        elif ("dvd+r" in mtype or "dvd-r" in mtype) and "rw" not in mtype:
+            props["ID_CDROM_MEDIA_DVD_PLUS_R"] = "1"
+        if info.get("rewritable"):
+            _tag_rewritable(props, mtype)
+        return props
     return {}
 
 
 def media_capacity_bytes(device):
+    if system_name() == "windows":
+        return _win_disc_info().get("capacity_bytes") or None
     if system_name() == "darwin":
         try:
             result = subprocess.run(["/usr/sbin/diskutil", "info", device], capture_output=True, text=True, check=False, timeout=3)
@@ -267,9 +361,28 @@ def tool(name):
     local = user_home() / ".local" / "bin" / name
     if local.exists():
         return str(local)
+    # pip-installed console scripts (yt-dlp, etc. from requirements.txt) land
+    # in the venv's own Scripts/bin dir, which isn't necessarily on PATH -
+    # e.g. the Windows Scheduled Task runs pythonw.exe directly, no shell
+    # activation. sys.exec_prefix is the venv root we're actually running in.
+    venv_bin = Path(sys.exec_prefix) / ("Scripts" if system_name() == "windows" else "bin")
+    for candidate_name in ((name + ".exe", name) if system_name() == "windows" else (name,)):
+        candidate = venv_bin / candidate_name
+        if candidate.exists():
+            return str(candidate)
     path = shutil.which(name)
     if path:
         return path
+    if system_name() == "windows":
+        # install-windows.ps1's no-winget fallback downloads ffmpeg/yt-dlp
+        # into config_dir()/tools (e.g. an extracted "ffmpeg-9.0-essentials
+        # build\bin\"), and only puts it on the *installer script's own*
+        # session PATH - gone the moment the installer exits. Search that
+        # tree directly instead of relying on PATH.
+        exe = name if name.lower().endswith(".exe") else name + ".exe"
+        match = next((config_dir() / "tools").rglob(exe), None) if (config_dir() / "tools").exists() else None
+        if match:
+            return str(match)
     if system_name() == "darwin":
         candidates = [
             Path("/opt/homebrew/bin") / name,
@@ -451,6 +564,12 @@ def eject_device(device, close=False):
             except (OSError, subprocess.TimeoutExpired):
                 pass
         return False
+    elif system == "windows":
+        args = [device] if device else []
+        if close:
+            args.append("-Close")
+        rc, _, _ = _run_ps("eject.ps1", *args, timeout=20)
+        return rc == 0
     else:
-        raise RuntimeError("Automatic optical-drive eject is not implemented on Windows")
+        raise RuntimeError("Automatic optical-drive eject is not implemented on this OS")
     return subprocess.run(command, capture_output=True, text=True, timeout=10).returncode == 0

package/src/static/app.js

@@ -66,6 +66,7 @@
       setConnection(true);
       setLiveStatus(progress.status);
       setProgress(progress.status, Number(progress.progress), progress.active);
+      applyRemoteState(progress);
     } catch (_) {
       setConnection(false);
       setLiveStatus("OFFLINE");
@@ -73,10 +74,67 @@
     }
   }
 
+  // --- On-screen remote: the exact same text commands the ESP32 sends -----
+  // POSTed to /remote/button, which feeds a VirtualSerial standing in for a
+  // real appliance. Only usable when no hardware remote is attached.
+  const remoteKey = "discstation-remote-visible";
+
+  function setRemoteVisible(visible, persist = false) {
+    $("remote-panel").hidden = !visible;
+    $("brand-link").classList.toggle("remote-active", visible);
+    if (persist) localStorage.setItem(remoteKey, visible ? "1" : "0");
+  }
+
+  function toggleRemotePanel() {
+    setRemoteVisible($("remote-panel").hidden, true);
+  }
+
+  function applyRemoteState(progress) {
+    const hardware = progress.appliance === "hardware";
+    if (hardware && !$("remote-panel").hidden) setRemoteVisible(false, true);
+    $("remote-note").textContent = hardware
+      ? "A physical remote is attached — on-screen controls are disabled."
+      : "No physical remote detected — control DiscStation from here.";
+    $("remote-controls").querySelectorAll("button, input").forEach((el) => { el.disabled = hardware; });
+    $("remote-transport").hidden = !progress.playing;
+    const ejectBtn = $("remote-eject-btn");
+    const open = !!progress.tray_open;
+    ejectBtn.textContent = open ? "CLOSE TRAY" : "EJECT";
+    ejectBtn.dataset.cmd = open ? "CONFIRM" : "EJECT";
+  }
+
+  async function sendRemoteCmd(cmd) {
+    try {
+      await fetch("/remote/button", {
+        method: "POST",
+        headers: { "Content-Type": "application/x-www-form-urlencoded" },
+        body: new URLSearchParams({ cmd })
+      });
+    } catch (_) { /* next poll/SSE tick reflects reality */ }
+  }
+
+  $("brand-link").addEventListener("click", (event) => {
+    event.preventDefault();
+    toggleRemotePanel();
+  });
+  setRemoteVisible(localStorage.getItem(remoteKey) === "1");
+
+  $("remote-controls").addEventListener("click", (event) => {
+    const button = event.target.closest("[data-cmd]");
+    if (button && !button.disabled) sendRemoteCmd(button.dataset.cmd);
+  });
+  let volumeTimer;
+  $("remote-volume").addEventListener("input", (event) => {
+    clearTimeout(volumeTimer);
+    const value = event.target.value;
+    volumeTimer = setTimeout(() => sendRemoteCmd(`POT:${value}`), 150);
+  });
+
   async function loadDiscInfo() {
     try {
       const response = await fetch("/disc-info", { cache: "no-store" });
       const info = await response.json();
+      renderDiscStatus(info);
       if (info.busy) return;               // burn/rip in progress — keep current
       state.discBytes = Number(info.capacity_bytes || 0);
       state.discType = info.type || "none";
@@ -84,9 +142,22 @@
     } catch (_) {
       state.discBytes = 0;
       state.discType = "none";
+      renderDiscStatus(null);
     }
   }
 
+  function renderDiscStatus(info) {
+    const el = $("remote-disc-status");
+    if (!el) return;
+    if (!info) { el.textContent = "DISC: UNKNOWN"; return; }
+    if (info.busy) { el.textContent = "DISC: BUSY (see status above)"; return; }
+    if (!info.disc_present) { el.textContent = "DISC: NONE"; return; }
+    const kind = (info.type || info.kind || "unknown").toUpperCase();
+    const label = info.label ? ` "${info.label}"` : "";
+    const size = info.capacity_gb ? ` // ${info.capacity_gb}GB` : "";
+    el.textContent = `DISC: ${kind}${label}${size}`;
+  }
+
   function renderSelection() {
     const list = $("selection-list");
     const total = state.entries.reduce((sum, entry) => sum + entry.file.size, 0);
@@ -269,6 +340,7 @@
       setConnection(true);
       setLiveStatus(d.status);
       setProgress(d.status, Number(d.progress), d.active);
+      applyRemoteState(d);
     });
     es.addEventListener("open", () => { setConnection(true); loadDiscInfo(); });
     es.addEventListener("error", () => {

package/src/static/index.html

@@ -13,9 +13,10 @@
 <body>
   <div class="page-shell">
     <header class="topbar">
-      <a class="brand" href="/" aria-label="DiscStation home">
+      <a class="brand" href="/" id="brand-link" aria-label="DiscStation home / toggle remote">
         <span class="brand-mark">DS</span>
         <span>DISCSTATION</span>
+        <span id="remote-hint" class="remote-hint">REMOTE</span>
       </a>
       <div class="topbar-actions">
         <button id="theme-toggle" class="theme-toggle" type="button" aria-label="Switch to dark mode">&#x263E;</button>
@@ -34,6 +35,39 @@
         <div><strong>04</strong><span>RIP / PLAY</span></div>
       </section>
 
+      <section id="remote-panel" class="remote-panel section-rule" hidden aria-labelledby="remote-title">
+        <div class="panel-heading">
+          <div>
+            <div class="section-kicker">ON-SCREEN REMOTE</div>
+            <h2 id="remote-title">CONTROL SURFACE</h2>
+          </div>
+          <span class="panel-index">DISCSTN-02</span>
+        </div>
+        <p id="remote-note" class="field-note"></p>
+        <div id="remote-disc-status" class="remote-disc-status">DISC: CHECKING</div>
+        <div id="remote-controls">
+          <div class="remote-grid">
+            <button class="outline-button" type="button" data-cmd="SELECT:BURN">BURN</button>
+            <button class="outline-button" type="button" data-cmd="SELECT:BURN DATA">BURN DATA</button>
+            <button class="outline-button" type="button" data-cmd="SELECT:BURN AUDIO">BURN AUDIO</button>
+            <button class="outline-button" type="button" data-cmd="SELECT:RIP">RIP</button>
+            <button class="outline-button" type="button" data-cmd="SELECT:PLAY">PLAY</button>
+            <button class="outline-button" type="button" data-cmd="CANCEL">CANCEL / HOME</button>
+            <button class="outline-button" type="button" id="remote-eject-btn" data-cmd="EJECT">EJECT</button>
+          </div>
+          <div id="remote-transport" class="remote-transport" hidden>
+            <div class="remote-grid">
+              <button class="outline-button" type="button" data-cmd="REW:BIG">&#x23EE; PREV</button>
+              <button class="outline-button" type="button" data-cmd="PLAY_BUTTON">&#x23EF; PLAY/PAUSE</button>
+              <button class="outline-button" type="button" data-cmd="FF:BIG">&#x23ED; NEXT</button>
+              <button class="outline-button" type="button" data-cmd="PLAY_STOP">&#x23F9; STOP</button>
+            </div>
+            <label class="field-label" for="remote-volume">VOLUME</label>
+            <input id="remote-volume" type="range" min="0" max="100" value="70">
+          </div>
+        </div>
+      </section>
+
       <section class="burn-panel section-rule" aria-labelledby="burn-title">
         <div class="panel-heading">
           <div>
@@ -105,7 +139,7 @@
     </footer>
   </div>
   <div id="install-slot"></div>
-  <script>if ("serviceWorker" in navigator) navigator.serviceWorker.register("/sw.js?v=8").catch(() => {});</script>
-  <script src="/static/app.js?v=8" defer></script>
+  <script>if ("serviceWorker" in navigator) navigator.serviceWorker.register("/sw.js?v=17").catch(() => {});</script>
+  <script src="/static/app.js?v=17" defer></script>
 </body>
 </html>

package/src/static/style.css

@@ -99,6 +99,27 @@ button { color: inherit; }
   color: var(--ink);
   text-decoration: none;
   font-weight: 700;
+  cursor: pointer;
+}
+
+.remote-hint {
+  display: inline-flex;
+  align-items: center;
+  height: 16px;
+  padding: 0 6px;
+  border: 1px solid var(--soft-line);
+  color: var(--muted);
+  font-size: 8px;
+  font-weight: 700;
+  letter-spacing: 0.08em;
+  white-space: nowrap;
+  text-shadow: none;
+  transition: color 0.2s ease, border-color 0.2s ease, text-shadow 0.2s ease;
+}
+.brand.remote-active .remote-hint {
+  color: var(--ink);
+  border-color: var(--ink);
+  text-shadow: 0 0 6px var(--accent);
 }
 
 .brand-mark {
@@ -278,6 +299,21 @@ h2 { margin-top: 8px; font-family: var(--display); font-size: clamp(30px, 7vw, 6
 .form-message.error { color: #9d4035; }
 .form-message.ok { color: #287346; }
 
+.remote-panel { padding: 26px 0 30px; }
+.remote-disc-status {
+  margin: 10px 0 4px;
+  padding: 10px 12px;
+  border: 1px solid var(--ink);
+  background: var(--surface);
+  font-size: 11px;
+  font-weight: 700;
+  letter-spacing: 0.06em;
+}
+.remote-grid { display: grid; grid-template-columns: repeat(2, 1fr); gap: 8px; margin-top: 16px; }
+#remote-controls button:disabled, #remote-controls input:disabled { cursor: not-allowed; opacity: 0.4; }
+.remote-transport { margin-top: 20px; padding-top: 18px; border-top: 1px solid var(--soft-line); }
+.remote-transport input[type="range"] { width: 100%; margin-top: 4px; accent-color: var(--accent); }
+
 .footer-stamp {
   display: flex;
   justify-content: space-between;
@@ -315,6 +351,8 @@ h2 { margin-top: 8px; font-family: var(--display); font-size: clamp(30px, 7vw, 6
   .capability-strip div:not(:last-child) { border-right: 1px solid var(--soft-line); }
   .capability-strip div + div { padding-left: 18px; }
   .burn-panel { width: min(100%, 720px); margin-left: auto; margin-right: auto; }
+  .remote-panel { width: min(100%, 720px); margin-left: auto; margin-right: auto; }
+  .remote-panel .remote-grid { grid-template-columns: repeat(3, 1fr); }
 }
 
 @media (max-width: 600px) {

package/src/win/_json.ps1

@@ -0,0 +1,29 @@
+# Minimal JSON emitter - works on PowerShell 2.0 (Win7) and up.
+function ConvertTo-JsonCompat {
+    param([Parameter(ValueFromPipeline = $true)] $obj)
+    if ($null -eq $obj) { return 'null' }
+    switch ($obj.GetType().Name) {
+        'Boolean'    { return $obj.ToString().ToLower() }
+        'Int32'      { return $obj.ToString() }
+        'Int64'      { return $obj.ToString() }
+        'Double'     { return $obj.ToString([System.Globalization.CultureInfo]::InvariantCulture) }
+        'String'     {
+            $s = $obj -replace '\\', '\\' -replace '"', '\"' -replace "`r", '\r' -replace "`n", '\n' -replace "`t", '\t'
+            return '"' + $s + '"'
+        }
+        'Hashtable'  {
+            $parts = @()
+            foreach ($k in $obj.Keys) { $parts += ('"' + $k + '":' + (ConvertTo-JsonCompat $obj[$k])) }
+            return '{' + ($parts -join ',') + '}'
+        }
+        'Object[]'   {
+            $parts = @()
+            foreach ($v in $obj) { $parts += (ConvertTo-JsonCompat $v) }
+            return '[' + ($parts -join ',') + ']'
+        }
+        default      {
+            $s = "$obj" -replace '\\', '\\' -replace '"', '\"'
+            return '"' + $s + '"'
+        }
+    }
+}