discstation 0.1.41 → 0.1.43

package/README.md

@@ -175,7 +175,11 @@ self-signed cert. On startup the host prints the LAN URL to open
   — and picking one starts it directly, no separate confirm step. Also has
   EJECT/CLOSE toggle, a live disc-status readout, and full playback
   transport. Greys out and auto-collapses the instant a physical remote is
-  detected, so the two never fight for control.
+  detected, so the two never fight for control — including mid-burn/rip/play:
+  plugging the remote in hands it control without interrupting whatever's
+  running, and its screen picks up the current status instead of starting
+  over; unplugging it hands control back to the on-screen remote within a
+  second or two.
 
 ## Mobile App
 
@@ -184,7 +188,8 @@ has the same on-screen remote as the web UI, rendered inline in the main
 screen rather than a popup — same "REMOTE" tag toggle, opens automatically
 with no ESP32 attached, mode buttons filtered to what the disc actually
 supports, and picking one starts it directly. Same auto-collapse behavior
-when a physical ESP32 shows up, same underlying `/remote/button` protocol.
+when a physical ESP32 shows up — mid-operation and without interruption, same
+as the web UI — and the same underlying `/remote/button` protocol.
 
 ## Disc Support
 

package/arduino/firmware/firmware.json

@@ -1 +1 @@
-{"version":"0.1.41","size":1260592,"md5":"e14a89bd9096d23ad5ca43b0a8d9bea0"}
+{"version":"0.1.43","size":1260592,"md5":"575faf0891e354ecd451d8454228a18e"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "discstation",
-  "version": "0.1.41",
+  "version": "0.1.43",
   "description": "DiscStation optical-media appliance host — one cross-OS installer",
   "bin": {
     "discstation-setup": "scripts/setup.mjs",

package/scripts/check.sh

@@ -66,6 +66,24 @@ d._remote_fw, d._remote_fw_asked = None, 0.0
 assert d._remote_update_state() == "unknown"
 d._appliance_mode = "software"
 assert d._remote_update_state() == ""
+
+# HybridSerial: web side when no remote, replay keeps the current screen, an unplug detaches quietly.
+d._replay.clear()
+for m in ("DISC:Audio CD", "HOME:Select mode", "PLAY_MODE:AUDIO_CD", "PLAY:PLAYING", "VU:1,2", "PING"):
+    d._remember(m)
+assert list(d._replay.values()) == ["DISC:Audio CD", "PLAY_MODE:AUDIO_CD", "PLAY:PLAYING"]
+d._remember("HOME:Select mode")
+assert list(d._replay.values()) == ["DISC:Audio CD", "HOME:Select mode"]
+h = d.HybridSerial()
+h.virtual.push_line("PLAY_BUTTON")
+assert h.in_waiting and h.readline() == b"PLAY_BUTTON\n" and h.write(b"x") == 1
+class Unplugged:
+    @property
+    def in_waiting(self): raise OSError("gone")
+    def close(self): pass
+d._appliance_mode = "hardware"
+h.hw = Unplugged()
+assert h.in_waiting == 0 and h.hw is None and d._appliance_mode == "software"
 print("smoke ok")
 EOF
 )

package/src/discstation.py

@@ -151,6 +151,7 @@ class TcpSerial:
         self._buf = b""
         self._lock = threading.Lock()
         self._alive = True
+        self.last_rx = time.monotonic()   # link monitor: silent this long = the remote is gone
         self._reader = threading.Thread(target=self._pump, daemon=True)
         self._reader.start()
 
@@ -168,6 +169,7 @@ class TcpSerial:
                 break
             if not chunk:
                 break
+            self.last_rx = time.monotonic()
             with self._lock:
                 self._buf += chunk
         self._alive = False
@@ -214,10 +216,199 @@ class TcpSerial:
         pass
 
 
-class _HardwareAttached(Exception):
-    """Raised out of station_loop when a real link (USB serial or the Wi-Fi
-    remote) appears while running on a VirtualSerial, so main() can hand
-    control over to it."""
+# What the remote's screen needs to be told again when it is plugged in mid-run:
+# the last message per prefix, so a remote attached during PLAY lands on the PLAY
+# screen instead of "Starting...". Activity messages belong to one operation and are
+# forgotten when a terminal message (back to a menu/standby, done, error) arrives.
+_REPLAY_ACTIVITY = ("PLAY_MODE", "PLAY_STATUS", "PLAY", "STATUS", "PROGRESS", "WAITING",
+                    "INFO", "TITLE", "META", "FIT", "WARNING")
+_REPLAY_TERMINAL = ("HOME", "STANDBY", "DONE", "ERROR", "CANCELLED")
+_REPLAY_STICKY = ("DISC", "DISC_NAME", "MENU_ITEMS", "IP")
+_replay = collections.OrderedDict()
+_replay_lock = threading.Lock()
+
+
+def _remember(msg):
+    prefix = msg.split(":", 1)[0]
+    if prefix in _REPLAY_TERMINAL:
+        drop = _REPLAY_ACTIVITY + _REPLAY_TERMINAL
+    elif prefix in _REPLAY_ACTIVITY:
+        drop = _REPLAY_TERMINAL   # the screen left the menu
+    elif prefix in _REPLAY_STICKY:
+        drop = ()
+    else:
+        return                    # VU frames, PING, VERSION, ...
+    with _replay_lock:
+        for k in drop:
+            _replay.pop(k, None)
+        _replay.pop(prefix, None)  # re-insert so dict order is send order
+        _replay[prefix] = msg
+
+
+class HybridSerial:
+    """The one link object station_loop and every flow hold for the life of the
+    process. It routes to the physical remote (USB serial or Wi-Fi) when one is
+    attached and to the web/app remote otherwise, and the link monitor swaps the
+    remote in and out underneath running flows - so plugging or unplugging it never
+    interrupts a burn/rip/play and never needs station_loop to restart."""
+
+    def __init__(self):
+        self.virtual = VirtualSerial()
+        self.hw = None
+
+    def detach(self, hw):
+        global _appliance_mode, _line_buf
+        if self.hw is not hw:
+            return
+        self.hw = None
+        _appliance_mode = "software"
+        _line_buf = b""
+        discstation_burn.reset_serial_state()
+        try:
+            hw.close()
+        except Exception:
+            pass
+        print("Remote disconnected - the web/app remote is active again.")
+        _sse_publish(_status_snapshot())
+
+    def _through(self, method, *args, default=b""):
+        hw = self.hw
+        if hw is None:
+            return getattr(self.virtual, method)(*args)
+        try:
+            return getattr(hw, method)(*args)
+        except (serial.SerialException, OSError):
+            self.detach(hw)
+            return default
+
+    @property
+    def in_waiting(self):
+        hw = self.hw
+        if hw is None:
+            return self.virtual.in_waiting
+        try:
+            return hw.in_waiting
+        except (serial.SerialException, OSError):
+            self.detach(hw)
+            return 0
+
+    def read(self, n=1):
+        return self._through("read", n)
+
+    def readline(self):
+        return self._through("readline")
+
+    def write(self, data):
+        if self.hw is None:
+            return len(data) if data else 0
+        return self._through("write", data, default=len(data) if data else 0)
+
+    def close(self):
+        hw = self.hw
+        if hw is not None:
+            try:
+                hw.close()
+            except Exception:
+                pass
+
+
+def _open_remote_link(look_for_wifi):
+    """Open the physical remote (USB serial wins, else the Wi-Fi remote) and wait for
+    its boot to finish. Returns the link or None. Runs on the monitor thread only."""
+    port = discstation_host.serial_port()
+    if port:
+        print(f"Using ESP32 serial port: {port}")
+        ser = serial.Serial(port, discstation_burn.BAUD, timeout=1, write_timeout=2)
+        if discstation_host.system_name() == "linux":
+            ser.setDTR(False)
+            time.sleep(0.1)
+            ser.setDTR(True)
+        deadline = time.monotonic() + 6
+        while time.monotonic() < deadline:
+            line = ser.readline().decode(errors="ignore").strip()
+            if line:
+                print(f"ESP32: {line}")
+            if "DISCSTATION_READY" in line:
+                break
+        return ser
+    if look_for_wifi:
+        remote = discstation_host.remote_host()
+        if remote:
+            try:
+                print(f"Connecting to Wi-Fi remote at {remote}:2323 ...")
+                link = TcpSerial(remote)
+                print(f"Wi-Fi remote link up ({remote}).")
+                return link
+            except OSError as e:
+                print(f"Wi-Fi remote {remote} unreachable ({e}); using web remote.")
+    return None
+
+
+def _attach_remote(hybrid, hw):
+    """Bring a freshly opened remote up to date and make it the active link."""
+    global _appliance_mode, _line_buf, _remote_fw, _remote_fw_asked
+    with discstation_burn.SERIAL_WRITE_LOCK:   # flows' sends wait, so none is lost mid-attach
+        with _replay_lock:
+            lines = list(_replay.values())
+        try:
+            for msg in lines + ["VERSION"]:
+                hw.write((msg + "\n").encode())
+        except (serial.SerialException, OSError):
+            try:
+                hw.close()
+            except Exception:
+                pass
+            return
+        _remote_fw, _remote_fw_asked = None, time.time()
+        discstation_burn.reset_serial_state()
+        _line_buf = b""
+        hybrid.hw = hw
+        hybrid.attached_at = time.monotonic()
+        _appliance_mode = "hardware"
+    print("Remote attached - control handed to the hardware remote.")
+    _sse_publish(_status_snapshot())
+
+
+def _link_monitor(hybrid, first_pass=False):
+    """Watches for the remote being plugged in / removed while flows run.
+    Not attached: look for USB every second, the Wi-Fi remote (mDNS) every 5 s.
+    Attached: keep it alive with PINGs and notice a dead link within seconds
+    (USB unplug shows up as an ioctl error at once; a Wi-Fi remote that goes
+    silent for 15 s is treated as gone)."""
+    last_wifi = last_ping = 0.0
+    logged_error = False
+    while True:
+        try:
+            hw = hybrid.hw
+            now = time.monotonic()
+            if hw is None:
+                wifi_due = now - last_wifi >= 5
+                if wifi_due:
+                    last_wifi = now
+                link = _open_remote_link(wifi_due)
+                logged_error = False
+                if link is not None:
+                    _attach_remote(hybrid, link)
+            else:
+                hw.in_waiting   # raises once the device is gone; does not consume bytes
+                silent = now - getattr(hw, "last_rx", now)
+                if silent > 15 and now - getattr(hybrid, "attached_at", now) > 15:
+                    raise serial.SerialException("remote stopped answering")
+                if now - last_ping >= 3:
+                    last_ping = now
+                    with discstation_burn.SERIAL_WRITE_LOCK:
+                        hw.write(b"PING\n")
+        except (serial.SerialException, OSError):
+            if hybrid.hw is not None:
+                hybrid.detach(hybrid.hw)
+            elif not logged_error:
+                logged_error = True
+                print("Remote found but could not be opened yet; retrying.")
+        except Exception as e:
+            print(f"Link monitor error: {e}")
+        if first_pass:
+            return
+        time.sleep(1)
 
 
 class _WebHandler(http.server.BaseHTTPRequestHandler):
@@ -337,8 +528,16 @@ class _WebHandler(http.server.BaseHTTPRequestHandler):
         if not cmd:
             self._respond(400, 'Missing cmd')
             return
-        if isinstance(_active_ser, VirtualSerial):
-            _active_ser.push_line(cmd)
+        if _active_ser is not None and _active_ser.hw is None:
+            _active_ser.virtual.push_line(cmd)
+            # One-click burn: chain START right behind SELECT:BURN* in the SAME
+            # request, atomically - station_loop's SELECT handler clears any
+            # stale buffered input the instant it reads the SELECT line, and a
+            # START sent as a second, separate HTTP call can land in that exact
+            # gap and get wiped (intermittent, timing-dependent "burn never
+            # starts" bug). Queuing both lines from one call removes the gap.
+            if cmd.upper().startswith("SELECT:BURN"):
+                _active_ser.virtual.push_line("START")
             self._respond(200, 'OK')
         else:
             self._respond(409, 'A hardware remote is attached')
@@ -361,7 +560,7 @@ class _WebHandler(http.server.BaseHTTPRequestHandler):
         global _ota_msg
         ser = _active_ser
         image, meta = _firmware_image()
-        if ser is None or isinstance(ser, VirtualSerial):
+        if ser is None or ser.hw is None:
             self._respond(409, 'No hardware remote attached')
         elif _operation_active:
             self._respond(409, 'Wait until the current operation finishes')
@@ -372,7 +571,7 @@ class _WebHandler(http.server.BaseHTTPRequestHandler):
         else:
             # the address the remote reaches us on: for the Wi-Fi link that is the
             # socket's own local address (also what the firmware checks it against)
-            host = ser.local_addr() if hasattr(ser, "local_addr") else local_ip()
+            host = ser.hw.local_addr() if hasattr(ser.hw, "local_addr") else local_ip()
             _ota_msg = ""
             discstation_burn.safe_send(ser, f"OTA_URL:http://{host}:{_HTTP_PORT}/firmware.bin|{meta['size']}|{meta['md5']}")
             _record_ota("0")
@@ -454,7 +653,7 @@ class _WebHandler(http.server.BaseHTTPRequestHandler):
     def _serve_sw(self):
         sw = '''self.addEventListener('install', e => {
   self.skipWaiting();
-  caches.open('discstation-v18').then(c => c.addAll(['/','/static/style.css?v=18','/static/app.js?v=18']));
+  caches.open('discstation-v20').then(c => c.addAll(['/','/static/style.css?v=20','/static/app.js?v=20']));
 });
 self.addEventListener('activate', e => e.waitUntil(clients.claim()));
 self.addEventListener('fetch', e => {
@@ -463,7 +662,7 @@ self.addEventListener('fetch', e => {
   if (path === '/' || path.startsWith('/static/')) {
     e.respondWith(fetch(e.request).then(r => {
       const copy = r.clone();
-      caches.open('discstation-v18').then(c => c.put(e.request, copy));
+      caches.open('discstation-v20').then(c => c.put(e.request, copy));
       return r;
     }).catch(() => caches.match(e.request)));
   } else {
@@ -654,6 +853,20 @@ def wait_for_web_url(ser):
     url = f"{protocol}://{ip}:{_web_port}"
     safe_send(ser, f"IP:{url}")
     print(f"URL displayed: {url}")
+    # The one-click remote buttons queue START right behind SELECT:BURN* (see
+    # _handle_remote_button) - when files were uploaded BEFORE the mode was
+    # picked (the normal one-click order), that START can already be sitting
+    # in the buffer by the time this runs. Check the queue before touching the
+    # serial line at all: the loop below reads and discards one line per pass
+    # looking for CANCEL/HOME, and would otherwise eat that START and throw it
+    # away, leaving the burn waiting forever for a START that already came.
+    try:
+        got = _burn_url_queue.get_nowait()
+    except Empty:
+        got = None
+    if got:
+        safe_send(ser, "STATUS:Got URL, starting...")
+        return got
     while True:
         line = read_serial_line(ser, timeout=0.5)
         if line and line.strip().upper() in ("CANCEL", "HOME"):
@@ -865,6 +1078,7 @@ def _set_web_progress(phase, percent=-1):
 
 def _record_web_status(msg):
     global _web_status, _web_progress, _web_progress_active, _web_playing
+    _remember(msg)
     if msg.startswith("DISC:"):
         _sse_publish({"type": "disc-changed"})
         return
@@ -1044,23 +1258,9 @@ discstation_burn.line_reader = read_serial_line
 
 
 def check_serial_alive(ser=None):
-    """Raise serial.SerialException if the ESP32 link looks dead, so main()'s
-    reconnect loop can re-scan for the (possibly renumbered) serial port.
-    Call this inside any long poll loop that would otherwise spin forever on a
-    stale handle (writes to a re-enumerated /dev/ttyUSBN fail silently).
-
-    Meaningless (and actively harmful) in pure web/software mode - there's no
-    ESP32 to go quiet, and serial_activity_age() only advances on real
-    incoming bytes, so a user just reading the screen for >35s before
-    clicking the next button on the web remote looked identical to a dead
-    link and killed the burn ("ESP32 not responding") with no ESP32 in the
-    picture at all."""
-    if isinstance(ser, VirtualSerial):
-        return
-    if discstation_burn.serial_write_failed():
-        raise serial.SerialException("serial write failed (ESP32 link lost)")
-    if discstation_burn.serial_activity_age() >= 35:
-        raise serial.SerialException("ESP32 not responding")
+    """Kept for the flows that call it inside long poll loops. The link monitor
+    (_link_monitor) now owns liveness and swaps a dead remote for the web remote
+    without raising, so a lost remote no longer aborts a burn/rip/play."""
 
 
 def send_disc_info(ser, device, status_line=None):
@@ -3049,7 +3249,7 @@ def _vu_loop(ser, stop_event, pause_event):
                 if proc.poll() is not None:
                     break
                 continue
-            if pause_event.is_set():
+            if pause_event.is_set() or ser.hw is None:   # nobody to draw bars for
                 continue
             samples = _np.frombuffer(raw, dtype=_np.int16).astype(_np.float32) / 32768.0
             spectrum = _np.abs(_np.fft.rfft(samples * window))
@@ -3081,9 +3281,9 @@ def _vu_loop(ser, stop_event, pause_event):
 
 def start_vu_visualizer(ser):
     """Best-effort: returns (stop_event, pause_event), or (None, None) if the
-    visualizer can't run here (no numpy, no PulseAudio, or a web-only link).
+    visualizer can't run here (no numpy, no PulseAudio).
     Linux only."""
-    if _np is None or isinstance(ser, VirtualSerial) or discstation_host.system_name() != "linux":
+    if _np is None or discstation_host.system_name() != "linux":
         return None, None
     stop_event = threading.Event()
     pause_event = threading.Event()
@@ -4084,19 +4284,7 @@ def station_loop(ser):
     except Exception:
         device = None  # empty drive (e.g. macOS after an eject) — keep the loop alive
 
-    for _ in range(50):
-        line = read_serial_line(ser, timeout=0.2)
-        if not line:
-            break
-        print(f"ESP32: {line}")
-        if "DISCSTATION_READY" in line:
-            break
-
     safe_send(ser, "STANDBY:Starting...")
-    if not isinstance(ser, VirtualSerial):
-        global _remote_fw, _remote_fw_asked
-        _remote_fw, _remote_fw_asked = None, time.time()
-        safe_send(ser, "VERSION")
 
     last_disc_line = None
     last_disc_poll = 0
@@ -4211,20 +4399,8 @@ def station_loop(ser):
         if now - last_ping >= 5:
             last_ping = now
             safe_send(ser, "PING")
-            if _remote_fw is None and not isinstance(ser, VirtualSerial):
+            if _remote_fw is None and ser.hw is not None:
                 safe_send(ser, "VERSION")  # the first ask can land while the remote is still booting
-            if isinstance(ser, VirtualSerial):
-                # Safe point (no flow active) to check whether a real link -
-                # USB serial or the Wi-Fi remote - has appeared, and hand off
-                # to it instead of the web remote.
-                try:
-                    link = discstation_host.serial_port() or discstation_host.remote_host()
-                except Exception:
-                    link = None
-                if link:
-                    raise _HardwareAttached(link)
-            else:
-                check_serial_alive(ser)
 
             # Slow full classify as a backstop (type changes, stuck "reading...").
             if (not _tray_open and _disc_poll_future is None
@@ -4328,8 +4504,7 @@ def station_loop(ser):
         # before its own START got consumed (e.g. never uploaded/confirmed a
         # URL), that stale START would otherwise sit buffered and fire this
         # new, different selection instead. Drop anything unconsumed first.
-        if isinstance(ser, VirtualSerial):
-            ser.clear()
+        ser.virtual.clear()
 
         # The user picked a mode — they want to act on a disc, so the drive is
         # fair game again even if it was ejected from the OLED earlier.
@@ -4416,7 +4591,7 @@ def parse_args():
 
 
 def main():
-    global _active_ser, _line_buf, _appliance_mode
+    global _active_ser, _appliance_mode
     signal.signal(signal.SIGTERM, signal.SIG_IGN)
     check_pidfile()
 
@@ -4427,71 +4602,35 @@ def main():
     try:
         start_web_server(args.port)
 
+        # One link object for the life of the process; the monitor thread swaps the
+        # physical remote (USB serial / Wi-Fi) in and out underneath running flows.
+        ser = HybridSerial()
+        _active_ser = ser
+        _appliance_mode = "software"
+        _link_monitor(ser, first_pass=True)   # a remote already plugged in is up before the menu starts
+        if ser.hw is None:
+            print("No ESP32 found - running in software-only mode (web remote).")
+        _sse_publish(_status_snapshot())
+        threading.Thread(target=_link_monitor, args=(ser,), daemon=True).start()
+
         while True:
             try:
-                _line_buf = b""
-                ser = None
-
-                # 1. USB serial wins whenever it's present (no mDNS scan then).
-                port = discstation_host.serial_port()
-                if port:
-                    print(f"Using ESP32 serial port: {port}")
-                    ser = serial.Serial(port, discstation_burn.BAUD, timeout=1, write_timeout=2)
-                    if discstation_host.system_name() == "linux":
-                        ser.setDTR(False)
-                        time.sleep(0.1)
-                        ser.setDTR(True)
-                    time.sleep(2)
-                    discstation_burn.reset_serial_state()
-                    _appliance_mode = "hardware"
-
-                # 2. Else look for a Wi-Fi remote (DISC_REMOTE_HOST, default auto/mDNS).
-                if ser is None:
-                    remote = discstation_host.remote_host()
-                    if remote:
-                        try:
-                            print(f"Connecting to Wi-Fi remote at {remote}:2323 ...")
-                            ser = TcpSerial(remote)
-                            discstation_burn.reset_serial_state()
-                            _appliance_mode = "hardware"
-                            print(f"Wi-Fi remote link up ({remote}).")
-                        except OSError as e:
-                            print(f"Wi-Fi remote {remote} unreachable ({e}); using web remote.")
-                            ser = None
-
-                # 3. Else the on-screen web/app remote is the control surface.
-                if ser is None:
-                    print("No ESP32 found - running in software-only mode (web remote).")
-                    ser = VirtualSerial()
-                    _appliance_mode = "software"
-                _active_ser = ser
-                # Nothing else publishes an SSE update purely for an appliance-
-                # mode flip (STATUS/PROGRESS/etc. events do, this doesn't) - push
-                # one now so a connected web remote learns about a newly-attached
-                # ESP32 immediately instead of only on its next reload.
-                _sse_publish(_status_snapshot())
                 station_loop(ser)
-            except _HardwareAttached:
-                print("ESP32 detected - handing off from the web remote to hardware.")
-            except (serial.SerialException, OSError, termios.error) as e:
-                print(f"Disconnected ({e}), reconnecting in 3s...")
-                time.sleep(3)
             except KeyboardInterrupt:
                 raise
-            finally:
-                _active_ser = None
-                if ser:
-                    try:
-                        ser.close()
-                    except Exception:
-                        pass
-                    ser = None
+            except (serial.SerialException, OSError, termios.error) as e:
+                print(f"Station loop error ({e}), restarting...")
+                time.sleep(1)
     except KeyboardInterrupt:
         print("\nStopped.")
         exit_code = 130
     except Exception as e:
         print(f"Error: {e}")
         exit_code = 1
+    finally:
+        _active_ser = None
+        if ser:
+            ser.close()
 
     if exit_code:
         sys.exit(exit_code)

package/src/static/app.js

@@ -51,11 +51,16 @@
   function setProgress(phase, percent, active = true) {
     const panel = $("global-progress");
     const fill = $("progress-fill");
-    panel.hidden = !active && percent < 0;
+    // Clamp here, the one place this renders - a browser's own upload
+    // "progress" event isn't guaranteed to stop exactly at loaded===total
+    // (seen reading past 100%), and this is the single choke point every
+    // caller (upload, burn/rip progress, SSE) goes through either way.
+    const shown = percent >= 0 ? Math.min(100, Math.max(0, Math.round(percent))) : -1;
+    panel.hidden = !active && shown < 0;
     $("progress-phase").textContent = (phase || "READY").toUpperCase();
-    $("progress-value").textContent = percent >= 0 ? `${percent}%` : "...";
-    fill.style.width = percent >= 0 ? `${Math.min(100, percent)}%` : "34%";
-    fill.classList.toggle("indeterminate", percent < 0);
+    $("progress-value").textContent = shown >= 0 ? `${shown}%` : "...";
+    fill.style.width = shown >= 0 ? `${shown}%` : "34%";
+    fill.classList.toggle("indeterminate", shown < 0);
   }
 
   async function pollStatus() {
@@ -154,16 +159,11 @@
     const button = event.target.closest("[data-cmd]");
     if (!button || button.disabled) return;
     const cmd = button.dataset.cmd;
+    // One-click burn: the server queues START right behind SELECT:BURN* in the
+    // same request now (was two separate POSTs from here, which raced against
+    // the server clearing stale input the instant it read SELECT and could
+    // silently drop the START - see _handle_remote_button in discstation.py).
     await sendRemoteCmd(cmd);
-    // On real hardware START is a long-press of the encoder on the burn-ready
-    // review screen, not its own button - a one-click "BURN AUDIO"/"BURN
-    // DATA"/"BURN" here is the whole point of the web remote, so chase the
-    // mode select straight through to starting the burn instead of leaving
-    // the user stuck with nothing left to press. (The backend queues this
-    // harmlessly if files/URL aren't in yet - it's only consumed once the
-    // burn's actually at its own "waiting for start" step, and gets flushed
-    // if a different mode gets selected first so it can't fire the wrong burn.)
-    if (cmd.startsWith("SELECT:BURN")) await sendRemoteCmd("START");
   });
   let volumeTimer;
   $("remote-volume").addEventListener("input", (event) => {

package/src/static/index.html

@@ -144,7 +144,7 @@
     </footer>
   </div>
   <div id="install-slot"></div>
-  <script>if ("serviceWorker" in navigator) navigator.serviceWorker.register("/sw.js?v=18").catch(() => {});</script>
-  <script src="/static/app.js?v=18" defer></script>
+  <script>if ("serviceWorker" in navigator) navigator.serviceWorker.register("/sw.js?v=20").catch(() => {});</script>
+  <script src="/static/app.js?v=20" defer></script>
 </body>
 </html>