discstation 0.1.18 → 0.1.20

package/README.md

@@ -64,7 +64,7 @@ Windows.
 |----|-----------|-----------------|
 | Linux | `install.sh` — apt deps, venv, systemd `--user` service, self-signed cert | full burn / rip / play |
 | macOS | `install-macos.sh` — Homebrew deps, venv, launchd agent, cert | burn / rip / play (audio-CD *burning* is best-effort; set `DISC_DEVICE` if detection fails) |
-| Windows | `install-windows.ps1` — files + venv | web / serial control only, no burn backend |
+| Windows | `install-windows.ps1` — Python + venv, self-signed cert, firewall rules, auto-start Scheduled Task | burn (ISO / data / audio CD) via IMAPI2 on Windows 10/11 and 7; DVD rip (HandBrake main-feature mode) and play (mpv) use the shared cross-platform path; full VIDEO_TS mirror rip and audio-CD rip aren't implemented on Windows yet |
 
 ### Or run the platform script directly
 
@@ -80,7 +80,7 @@ arduino-cli lib install QRCode
 # macOS host
 ./install-macos.sh
 
-# Windows host (web/control workflow)
+# Windows host
 PowerShell -ExecutionPolicy Bypass -File .\install-windows.ps1
 ```
 
@@ -88,8 +88,10 @@ PowerShell -ExecutionPolicy Bypass -File .\install-windows.ps1
 
 Linux and macOS both run the complete optical workflow (burn, rip, play) —
 macOS via `xorriso` / `hdiutil` / `cd-paranoia` / `dvdbackup` / HandBrake, with
-audio-CD *burning* the one best-effort area. Windows runs the shared Python/web
-workflow only; it has no burn backend yet. See `docs/PLATFORM_SUPPORT.md`.
+audio-CD *burning* the one best-effort area. Windows burns (ISO / data / audio
+CD) via IMAPI2 and plays via mpv; DVD ripping works in HandBrake main-feature
+mode but not full VIDEO_TS mirror or audio-CD ripping yet. See
+`docs/PLATFORM_SUPPORT.md`.
 
 ## Web Interface
 
@@ -114,7 +116,7 @@ Built-in web server on port 8080 (HTTPS with self-signed cert):
 | `DISC_CLEANUP_DAYS` | 2 | Auto-cleanup old job directories |
 | `DISC_OUTPUT_LIMIT_BYTES` | 4300000000 | Conservative DVD5 payload limit |
 | `DISC_DL_OUTPUT_LIMIT_BYTES` | 8000000000 | Conservative DVD9 payload limit |
-| `DISC_DEVICE` | auto | Optical drive node override (required on Windows) |
+| `DISC_DEVICE` | auto | Optical drive node override |
 | `DISC_PORT` | auto | ESP32 serial port override |
 | `DISCSTATION_HTTP_PORT` | 8081 | Plain-HTTP port for the mobile app (`0` disables) |
 | `DISCSTATION_DVD_RIP_MODE` | mirror | `mkv` = HandBrake main-feature transcode instead of a full VIDEO_TS mirror |

package/docs/PLATFORM_SUPPORT.md

@@ -29,10 +29,28 @@ the drive on recent macOS; DiscStation reports this clearly instead of hanging.
 
 ## Windows
 
-The Python host and web/control workflow can run from PowerShell. Optical
-burning needs a Windows IMAPI backend or a separately installed compatible
-burning tool. The Windows installer deliberately reports this limitation
-instead of silently attempting Linux commands.
+Runs the same Python host and web UI as Linux/macOS, triggered the same way
+via the ESP32 OLED remote. `install-windows.ps1` sets up Python + venv, a
+self-signed cert, firewall rules for 8080/8081, and a per-user auto-start
+Scheduled Task (headless `pythonw.exe`, no admin needed).
+
+- **Detect / eject** — WMI (`Win32_CDROMDrive`, `Win32_LogicalDisk`) + IMAPI2
+  for media type, blank/rewritable state, and capacity
+  (`src/win/disc-info.ps1`, `src/win/eject.ps1`).
+- **Burn** — data, ISO, and audio CD all go through IMAPI2
+  (`src/win/burn-{image,data,audio}.ps1`), with live progress streamed to the
+  OLED; `isoburn.exe /q` is the zero-dependency fallback for a raw ISO.
+  Works on Windows 7 SP1 and 10/11.
+- **Rip** — DVD main-feature mode via HandBrakeCLI (winget on 10/11) works;
+  a full unencrypted VIDEO_TS mirror and audio-CD ripping aren't implemented
+  yet (no Windows path for `dvdbackup`/`cd-paranoia`).
+- **Play** — `mpv`, via the same code path as Linux/macOS (device letter for
+  DVD-Video, `cdda://` for audio CD, mounted drive for data/VCD).
+
+Windows 7 (no `winget`) gets the host, detection, eject, and all three burn
+modes; rip/play need tools that don't install cleanly on 7, so those OLED
+actions report "not supported" there. Set `DISC_DEVICE` to override drive
+auto-detection.
 
 ## Shared Components
 
@@ -43,4 +61,5 @@ instead of silently attempting Linux commands.
 - QR-code web URL display
 
 The optical-drive backend is the platform boundary. Linux and macOS are
-complete (bar macOS audio-CD burning); Windows still needs its writer backend.
+complete (bar macOS audio-CD burning); Windows burns and plays, with DVD-mirror
+and audio-CD ripping still to come.

package/install-windows.ps1

@@ -1,29 +1,150 @@
+# DiscStation host installer for Windows 10/11 (and best-effort on 7 SP1).
+#   powershell -ExecutionPolicy Bypass -File install-windows.ps1
+# Sets up: Python + venv, optical CLI tools (winget), self-signed cert,
+# a per-user auto-start Scheduled Task, and inbound firewall rules for 8080/8081.
 $ErrorActionPreference = "Stop"
+$ProgressPreference = "SilentlyContinue"  # Invoke-WebRequest's progress bar breaks over SSH/non-interactive hosts
 
-$Root = Split-Path -Parent $MyInvocation.MyCommand.Path
-$App = if ($env:DISCSTATION_APP_DIR) { $env:DISCSTATION_APP_DIR } else { Join-Path $env:LOCALAPPDATA "DiscStation\app" }
-$Venv = if ($env:DISCSTATION_VENV_DIR) { $env:DISCSTATION_VENV_DIR } else { Join-Path $env:LOCALAPPDATA "DiscStation\venv" }
+$Root   = Split-Path -Parent $MyInvocation.MyCommand.Path
+$Base   = if ($env:DISCSTATION_CONFIG_DIR) { $env:DISCSTATION_CONFIG_DIR } else { Join-Path $env:APPDATA "DiscStation" }
+$App    = if ($env:DISCSTATION_APP_DIR)    { $env:DISCSTATION_APP_DIR }    else { Join-Path $Base "app" }
+$Venv   = if ($env:DISCSTATION_VENV_DIR)   { $env:DISCSTATION_VENV_DIR }   else { Join-Path $Base "venv" }
+$IsWin7 = [Environment]::OSVersion.Version.Major -eq 6
+$winget = (Get-Command winget -ErrorAction SilentlyContinue)
 
-if (-not (Get-Command py -ErrorAction SilentlyContinue)) {
-    throw "Install Python 3 from https://www.python.org/downloads/windows/ first."
+function Have($name) { [bool](Get-Command $name -ErrorAction SilentlyContinue) }
+function Winget-Install($id) {
+    if (-not $winget) { return $false }
+    try { winget install -e --id $id --accept-source-agreements --accept-package-agreements --silent | Out-Null; return $true }
+    catch { Write-Host "  winget $id failed (skipping)"; return $false }
 }
 
-New-Item -ItemType Directory -Force -Path $App, $Venv | Out-Null
+# --- 1. Python -------------------------------------------------------------------
+if (-not (Have "python") -and -not (Have "py")) {
+    Write-Host "Installing Python..."
+    if ($winget -and -not $IsWin7) {
+        Winget-Install "Python.Python.3.12" | Out-Null
+        $env:Path = [System.Environment]::GetEnvironmentVariable("Path", "User") + ";" + $env:Path
+    } else {
+        $pyver = if ($IsWin7) { "3.8.10" } else { "3.12.6" }
+        $url = "https://www.python.org/ftp/python/$pyver/python-$pyver-amd64.exe"
+        $exe = Join-Path $env:TEMP "python-$pyver-amd64.exe"
+        Invoke-WebRequest $url -OutFile $exe -UseBasicParsing
+        Start-Process $exe -ArgumentList "/quiet","InstallAllUsers=0","PrependPath=1","Include_test=0" -Wait
+        $env:Path = (Join-Path $env:LOCALAPPDATA "Programs\Python\Python$($pyver.Substring(0,4) -replace '\.','')") + ";" + $env:Path + ";" +
+                    (Join-Path $env:LOCALAPPDATA "Programs\Python\Python$($pyver.Substring(0,4) -replace '\.','')\Scripts")
+    }
+}
+if (Have "python") { $PyExe = "python"; $PyArgs = @() }
+elseif (Have "py") { $PyExe = "py"; $PyArgs = @("-3") }
+else { throw "Python install failed. Install Python 3 manually and re-run." }
+
+# --- 2. Optical CLI tools (winget when available; Win10/11 only; best-effort,
+#        strictly time-bounded so a slow/blocked mirror can never hang the install) --
+if ($winget -and -not $IsWin7) {
+    Write-Host "Installing optical tools via winget (best effort)..."
+    foreach ($id in "libburnia.xorriso","mpv.mpv","HandBrake.HandBrake.CLI","Gyan.FFmpeg","yt-dlp.yt-dlp") {
+        Winget-Install $id | Out-Null
+    }
+} elseif (-not $IsWin7) {
+    Write-Host "winget unavailable - fetching optical tools directly (best effort, 25s timeout each)..."
+    $tools = Join-Path $Base "tools"
+    New-Item -ItemType Directory -Force -Path $tools | Out-Null
+    function Get-Zip($url, $dest) {
+        try {
+            $zip = Join-Path $env:TEMP ([IO.Path]::GetFileName($url))
+            Invoke-WebRequest $url -OutFile $zip -UseBasicParsing -TimeoutSec 25
+            Expand-Archive -Path $zip -DestinationPath $dest -Force
+            Remove-Item $zip -ErrorAction SilentlyContinue
+            return $true
+        } catch { Write-Host "  fetch failed: $url"; return $false }
+    }
+    if (-not (Have "yt-dlp")) {
+        try { Invoke-WebRequest "https://github.com/yt-dlp/yt-dlp/releases/latest/download/yt-dlp.exe" -OutFile (Join-Path $tools "yt-dlp.exe") -UseBasicParsing -TimeoutSec 25 }
+        catch { Write-Host "  yt-dlp fetch skipped" }
+    }
+    if (-not (Have "ffmpeg")) { Get-Zip "https://www.gyan.dev/ffmpeg/builds/ffmpeg-release-essentials.zip" $tools | Out-Null }
+    if (-not (Have "mpv")) { Get-Zip "https://sourceforge.net/projects/mpv-player-windows/files/latest/download" $tools | Out-Null }
+    if (Test-Path $tools) {
+        $env:Path = $env:Path + ";" + $tools + ";" +
+            ((Get-ChildItem $tools -Recurse -Filter "ffmpeg.exe" -ErrorAction SilentlyContinue | Select-Object -First 1).DirectoryName)
+    }
+    Write-Host "xorriso and HandBrakeCLI have no simple direct-download URL - install manually if you need"
+    Write-Host "video-DVD authoring / DVD ripping (see the plan's Windows setup notes)."
+} else {
+    Write-Host "winget unavailable (Windows 7). ISO + data + audio burn work via IMAPI2."
+    Write-Host "For rip/play/video-DVD install manually: xorriso, HandBrakeCLI 1.5.1, ffmpeg, mpv, yt-dlp."
+}
+
+# --- 3. App files + venv ------------------------------------------------------
+New-Item -ItemType Directory -Force -Path $Base, $App | Out-Null
 Copy-Item -Recurse -Force (Join-Path $Root "src\*") $App
-py -3 -m venv $Venv
-& (Join-Path $Venv "Scripts\python.exe") -m pip install --upgrade pip
+& $PyExe @PyArgs -m venv $Venv
 $Py = Join-Path $Venv "Scripts\python.exe"
+& $Py -m pip install --upgrade pip
 $Req = Join-Path $Root "requirements.txt"
-if (Test-Path $Req) {
-    & $Py -m pip install -r $Req
-} else {
-    & $Py -m pip install pyserial mutagen requests yt-dlp
+if (Test-Path $Req) { & $Py -m pip install -r $Req } else { & $Py -m pip install pyserial mutagen requests yt-dlp }
+$Opt = Join-Path $Root "requirements-optional.txt"
+try { if (Test-Path $Opt) { & $Py -m pip install -r $Opt } else { & $Py -m pip install musicbrainzngs tmdbsimple } }
+catch { Write-Host "Optional metadata deps skipped (host still works)." }
+
+# --- 4. Self-signed cert (HTTPS on :8080; :8081 works without it) --------------
+$crt = Join-Path $Base "server.crt"; $key = Join-Path $Base "server.key"
+if (-not (Test-Path $crt) -or -not (Test-Path $key)) {
+    try {
+        $c = New-SelfSignedCertificate -DnsName "discstation.local" -CertStoreLocation "Cert:\CurrentUser\My" -NotAfter (Get-Date).AddYears(10)
+        $pwd = ConvertTo-SecureString -String "discstation" -Force -AsPlainText
+        $pfx = Join-Path $env:TEMP "ds.pfx"
+        Export-PfxCertificate -Cert $c -FilePath $pfx -Password $pwd | Out-Null
+        & $Py -c "import ssl" 2>$null
+        # Convert PFX -> PEM via Python cryptography if present, else leave HTTPS off.
+        & $Py -m pip install cryptography 2>$null
+        & $Py -c "import sys;from cryptography.hazmat.primitives.serialization import pkcs12,Encoding,PrivateFormat,NoEncryption;d=open(sys.argv[1],'rb').read();k,c,_=pkcs12.load_key_and_certificates(d,b'discstation');open(sys.argv[2],'wb').write(c.public_bytes(Encoding.PEM));open(sys.argv[3],'wb').write(k.private_bytes(Encoding.PEM,PrivateFormat.TraditionalOpenSSL,NoEncryption()))" $pfx $crt $key
+        Remove-Item $pfx -ErrorAction SilentlyContinue
+    } catch { Write-Host "Cert generation skipped; the host will serve plain HTTP on 8081." }
 }
-# Optional metadata deps — best effort, never fatal.
-try { & $Py -m pip install musicbrainzngs tmdbsimple } catch {
-    Write-Host "Optional metadata deps skipped (host still works)."
+
+# --- 5. Firewall -------------------------------------------------------------
+foreach ($port in 8080, 8081) {
+    $name = "DiscStation $port"
+    try {
+        if (Get-Command New-NetFirewallRule -ErrorAction SilentlyContinue) {
+            if (-not (Get-NetFirewallRule -DisplayName $name -ErrorAction SilentlyContinue)) {
+                New-NetFirewallRule -DisplayName $name -Direction Inbound -Action Allow -Protocol TCP -LocalPort $port | Out-Null
+            }
+        } else {
+            netsh advfirewall firewall add rule name="$name" dir=in action=allow protocol=TCP localport=$port | Out-Null
+        }
+    } catch {}
 }
 
-Write-Host "DiscStation host files installed at $App"
-Write-Host "The web/control workflow is available; optical burning requires a Windows IMAPI backend or compatible burning tools."
-Write-Host "Run: $Venv\Scripts\python.exe $App\discstation.py"
+# --- 6. Auto-start Scheduled Task -----------------------------------------------
+$pyw = Join-Path $Venv "Scripts\pythonw.exe"
+$target = Join-Path $App "discstation.py"
+try {
+    if (Get-Command Register-ScheduledTask -ErrorAction SilentlyContinue) {
+        $action    = New-ScheduledTaskAction -Execute $pyw -Argument "`"$target`"" -WorkingDirectory $App
+        $trigger   = New-ScheduledTaskTrigger -AtLogOn -User $env:USERNAME
+        $set       = New-ScheduledTaskSettingsSet -AllowStartIfOnBatteries -DontStopIfGoingOnBatteries -RestartCount 3 -RestartInterval (New-TimeSpan -Minutes 1)
+        # S4U: runs headlessly for this user without needing an active interactive
+        # desktop session (Interactive logon type only fires while one exists, so
+        # e.g. Start-ScheduledTask over SSH/no console session would silently no-op).
+        # RunLevel Limited (standard, non-elevated): nothing here needs admin -
+        # IMAPI2 burning, WMI reads, and binding ports >1024 all work as a normal
+        # user, and elevation is what put "Administrator" on the flashing console
+        # windows this used to spawn.
+        $principal = New-ScheduledTaskPrincipal -UserId $env:USERNAME -LogonType S4U -RunLevel Limited
+        Register-ScheduledTask -TaskName "DiscStation" -Action $action -Trigger $trigger -Settings $set -Principal $principal -Force | Out-Null
+        Start-ScheduledTask -TaskName "DiscStation"
+    } else {
+        schtasks /create /tn "DiscStation" /sc onlogon /f /tr "`"$pyw`" `"$target`"" | Out-Null
+        schtasks /run /tn "DiscStation" | Out-Null
+    }
+} catch { Write-Host "Auto-start task not created: $_" }
+
+$ip = (Get-NetIPAddress -AddressFamily IPv4 -ErrorAction SilentlyContinue | Where-Object { $_.IPAddress -notmatch '^127\.|^169\.254\.' } | Select-Object -First 1).IPAddress
+Write-Host ""
+Write-Host "DiscStation installed at $App"
+Write-Host "  Web UI:  http://localhost:8081/   (also http://$ip`:8081 on the LAN)"
+Write-Host "  Run 'discstation' any time to open it. Detection/eject/ISO+data+audio burn use IMAPI2 (no extra tools)."
+try { node (Join-Path $Root "scripts\open.mjs") } catch {}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "discstation",
-  "version": "0.1.18",
+  "version": "0.1.20",
   "description": "DiscStation optical-media appliance host — one cross-OS installer",
   "bin": {
     "discstation-setup": "scripts/setup.mjs",
@@ -21,6 +21,7 @@
     "scripts/",
     "src/*.py",
     "src/static/",
+    "src/win/",
     "arduino/",
     "systemd/",
     "docs/",

package/scripts/setup.mjs

@@ -19,7 +19,7 @@ if (args.includes('-h') || args.includes('--help')) {
 Runs the installer for the current OS:
   linux    install.sh          full: apt deps, venv, systemd --user service, self-signed cert
   darwin   install-macos.sh    full: Homebrew deps, venv, launchd agent, cert (audio-CD burn is best-effort)
-  windows  install-windows.ps1 files + venv only; web/serial control, no burn backend
+  windows  install-windows.ps1 venv + cert + firewall + auto-start task; burn via IMAPI2 (10/11 and 7)
 
 Prereqs: Node 16+, Python 3 (python3 / py on PATH), and either bash (linux/macOS)
 or PowerShell (Windows). Homebrew is auto-installed on macOS if missing; the

package/src/discstation.py

@@ -4,7 +4,10 @@ import atexit
 import collections
 import concurrent.futures
 import errno
-import fcntl
+try:
+    import fcntl  # POSIX-only; used only in drive_status()'s Linux branch
+except ImportError:
+    fcntl = None
 import json
 import mimetypes
 import os
@@ -16,7 +19,10 @@ except ImportError:
 import re
 import shutil
 import socket
-import ssl
+try:
+    import ssl  # optional: HTTPS on :8080. The plain-HTTP :8081 listener works without it.
+except ImportError:
+    ssl = None
 import subprocess
 import sys
 import tempfile
@@ -349,13 +355,17 @@ def start_web_server(port=8080):
     cert_dir = discstation_host.config_dir()
     cert = cert_dir / 'server.crt'
     key = cert_dir / 'server.key'
-    if cert.exists() and key.exists():
-        ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
-        ctx.load_cert_chain(str(cert), str(key))
-        server.socket = ctx.wrap_socket(server.socket, server_side=True)
-        print(f"Web interface on https://0.0.0.0:{port}")
+    if ssl is not None and cert.exists() and key.exists():
+        try:
+            ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
+            ctx.load_cert_chain(str(cert), str(key))
+            server.socket = ctx.wrap_socket(server.socket, server_side=True)
+            print(f"Web interface on https://0.0.0.0:{port}")
+        except (ssl.SSLError, OSError) as e:
+            print(f"TLS disabled ({e}); serving plain HTTP on {port}")
     else:
-        print(f"Web interface on http://0.0.0.0:{port}")
+        print(f"Web interface on http://0.0.0.0:{port}"
+              + ("" if ssl is not None else " (ssl module unavailable)"))
 
     _web_server = server
     t = threading.Thread(target=server.serve_forever, daemon=True)
@@ -422,7 +432,8 @@ def wait_for_web_url(ser):
             check_serial_alive(ser)
 
 
-MPV_SOCKET = str(Path(tempfile.gettempdir()) / "discstation_mpv.sock")
+MPV_SOCKET = (r"\\.\pipe\discstation-mpv" if os.name == "nt"
+              else str(Path(tempfile.gettempdir()) / "discstation_mpv.sock"))
 RIP_ROOT = discstation_burn.USER_HOME / "dvd_rips"
 USER_AGENT = "DVDStation/0.1 (local appliance; phuju)"
 DISC_POLL_SECONDS = 6
@@ -649,12 +660,26 @@ def chown_to_sudo_user(path):
                 pass
 
 
+def _mpv_ipc(payload, timeout=None):
+    """Send one JSON line to mpv's IPC endpoint. Windows = named pipe, POSIX =
+    AF_UNIX socket. Returns the raw reply bytes (b"" if not read), or raises OSError."""
+    if os.name == "nt":
+        with open(MPV_SOCKET, "r+b", buffering=0) as pipe:
+            pipe.write(payload)
+            if timeout is None:
+                return b""
+            return pipe.read(4096) or b""
+    with socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) as sock:
+        if timeout is not None:
+            sock.settimeout(timeout)
+        sock.connect(MPV_SOCKET)
+        sock.sendall(payload)
+        return sock.recv(4096) if timeout is not None else b""
+
+
 def mpv_command(command):
     try:
-        payload = json.dumps({"command": command}).encode() + b"\n"
-        with socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) as sock:
-            sock.connect(MPV_SOCKET)
-            sock.sendall(payload)
+        _mpv_ipc(json.dumps({"command": command}).encode() + b"\n")
     except OSError:
         return False
     return True
@@ -663,11 +688,7 @@ def mpv_command(command):
 def mpv_query(command):
     try:
         payload = json.dumps({"command": command, "request_id": 1}).encode() + b"\n"
-        with socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) as sock:
-            sock.settimeout(0.5)
-            sock.connect(MPV_SOCKET)
-            sock.sendall(payload)
-            response = json.loads(sock.recv(4096).decode(errors="ignore"))
+        response = json.loads(_mpv_ipc(payload, timeout=0.5).decode(errors="ignore"))
         return response.get("data")
     except (OSError, ValueError, json.JSONDecodeError):
         return None
@@ -678,14 +699,11 @@ def wait_for_socket(path, proc, timeout=8):
     while time.time() < deadline:
         if proc.poll() is not None:
             return False
-        if Path(path).exists():
-            try:
-                with socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) as sock:
-                    sock.settimeout(0.25)
-                    sock.connect(path)
-                return True
-            except OSError:
-                pass
+        try:
+            _mpv_ipc(b'{"command":["get_property","idle-active"]}\n', timeout=0.25)
+            return True
+        except OSError:
+            pass
         time.sleep(0.1)
     return False
 
@@ -998,11 +1016,28 @@ _tray_open = False
 _tray_open_since = 0.0  # time.monotonic() of the last OLED-initiated eject
 
 
+def _device_present(device):
+    """Is `device` still a live drive node? On Linux/macOS that's a real
+    filesystem path that can disappear (e.g. after an eject) - Path.exists()
+    answers that correctly. On Windows `device` is a bare drive letter ("D:");
+    Path("D:").exists() raises OSError (WinError 1) instead of returning False,
+    and the drive letter is stable regardless of media state anyway (the real
+    presence signal is ID_CDROM_MEDIA, checked downstream via media_properties())."""
+    if not device:
+        return False
+    if discstation_host.system_name() == "windows":
+        return True
+    try:
+        return Path(device).exists()
+    except OSError:
+        return False
+
+
 def _tray_closed_with_disc(device):
     if not device:
         return False
     global _tray_open
-    if not Path(device).exists():
+    if not _device_present(device):
         return False
     properties = udev_cdrom_properties(device)
     if properties.get("ID_CDROM_MEDIA") == "1":
@@ -1021,7 +1056,7 @@ def disc_present(device):
         return True
     if _tray_open:
         return False
-    if not Path(device).exists():
+    if not _device_present(device):
         return False
     if discstation_host.system_name() != "linux":
         properties = udev_cdrom_properties(device)
@@ -1055,7 +1090,7 @@ def disc_present(device):
 def is_blank_disc(device):
     if not device:
         return False
-    if not Path(device).exists():
+    if not _device_present(device):
         return False
 
     properties = udev_cdrom_properties(device, refresh=True)
@@ -1107,7 +1142,7 @@ def is_rewritable_disc(device):
     if not device:
         return False
     """Return whether the inserted medium can be overwritten."""
-    if not Path(device).exists():
+    if not _device_present(device):
         return False
 
     properties = udev_cdrom_properties(device)
@@ -1227,7 +1262,7 @@ def _media_quick_state(device, props):
         return "unsure"
     # st == "unknown": fall through to the legacy probes below
     try:
-        if not Path(device).exists():
+        if not _device_present(device):
             return "empty"
     except OSError:
         return "empty"
@@ -1317,6 +1352,11 @@ def _classify_disc(device, props, failed, deadline):
     (blkid -> lsdvd -> wodim -toc -> fs fallback -> blank) but records which
     probes timed out / were missing so the caller can retry."""
     if discstation_host.system_name() != "linux":
+        if not props.get("ID_CDROM_MEDIA"):
+            # media_properties() returned nothing -> no disc loaded (this is the
+            # only "no media" signal on a platform like Windows where the drive
+            # letter/device path exists whether or not media is present).
+            return _disc_info(False, "none")
         if props.get("ID_CDROM_MEDIA_TYPE") == "audio":
             return _disc_info(True, "audio_cd", web_type="AUDIO_CD")
         if props.get("ID_FS_TYPE") in ("udf", "iso9660"):
@@ -1627,6 +1667,11 @@ class mounted_disc:
         self.owned_mount = False
 
     def __enter__(self):
+        if discstation_host.system_name() == "windows":
+            # the optical disc is already mounted by the OS as its drive letter
+            letter = str(self.device).rstrip("\\/").rstrip(":") + ":\\"
+            self.mount_path = Path(letter)
+            return self.mount_path
         if discstation_host.system_name() == "darwin":
             properties = discstation_host.media_properties(self.device)
             existing_mount = properties.get("ID_MOUNT_POINT")
@@ -1688,6 +1733,24 @@ def disc_video_files(mount_dir):
 
 
 def audio_cd_toc(device):
+    if discstation_host.system_name() == "windows":
+        rc, out, err = discstation_host._run_ps("audio-toc.ps1", device, timeout=25)
+        info = {}
+        for line in out.splitlines():
+            if line.strip().startswith("{"):
+                try:
+                    info = json.loads(line)
+                except ValueError:
+                    pass
+        tracks = info.get("tracks") or []
+        if not tracks:
+            raise RuntimeError(f"Could not read CD TOC: {(err or out)[:120]}")
+        n = int(info["track_count"])
+        return {
+            "first_track": 1, "track_count": n, "leadout": int(info["leadout"]),
+            "tracks": tracks,
+            "toc": "+".join(map(str, [1, n, int(info["leadout"]), *tracks])),
+        }
     if discstation_host.system_name() == "darwin":
         paranoia = None
         for name in ("cd-paranoia", "cdparanoia"):
@@ -1767,7 +1830,7 @@ def audio_cd_toc(device):
 
 
 def audio_cd_chapters(device):
-    if discstation_host.system_name() == "darwin":
+    if discstation_host.system_name() in ("darwin", "windows"):
         toc = audio_cd_toc(device)
         tracks = toc["tracks"]
         first = tracks[0]
@@ -2413,9 +2476,18 @@ def directory_size_bytes(path):
     return total
 
 
+def _stdin_is_tty():
+    """sys.stdin is None under pythonw.exe (no console) - plain .isatty() would
+    AttributeError. Also guards a closed/redirected stdin under systemd/launchd."""
+    try:
+        return sys.stdin is not None and sys.stdin.isatty()
+    except (AttributeError, ValueError, OSError):
+        return False
+
+
 def burn_flow(ser, url):
     if not url:
-        if sys.stdin.isatty():
+        if _stdin_is_tty():
             safe_send(ser, "STATUS:Enter URL or file path in terminal")
             print("=== Enter URL or file path below, then press Enter ===")
             try:
@@ -2671,7 +2743,7 @@ def burn_data_flow(ser):
     if _last_upload_dir and Path(_last_upload_dir).exists():
         url = _last_upload_dir
         _last_upload_dir = None
-    elif sys.stdin.isatty():
+    elif _stdin_is_tty():
         safe_send(ser, "STATUS:Enter URL or file path in terminal")
         print("=== Enter URL or file path below, then press Enter ===")
         try:
@@ -2836,7 +2908,7 @@ def burn_data_flow(ser):
 
 
 def burn_audio_flow(ser):
-    if sys.stdin.isatty():
+    if _stdin_is_tty():
         safe_send(ser, "STATUS:Enter path to audio files in terminal")
         print("=== Enter path to audio files/folder, then press Enter ===")
         try:
@@ -3017,7 +3089,7 @@ def _iter_proc_lines(proc, ser):
 def _run_mpv(ser, cmd, label, kind=None, track_titles=None, track_starts=None):
     try:
         os.unlink(MPV_SOCKET)
-    except FileNotFoundError:
+    except OSError:
         pass
 
     env = os.environ.copy()
@@ -3157,7 +3229,7 @@ def _run_mpv(ser, cmd, label, kind=None, track_titles=None, track_starts=None):
             discstation_burn.stop_process(proc)
         try:
             os.unlink(MPV_SOCKET)
-        except FileNotFoundError:
+        except OSError:
             pass
 
 
@@ -3979,7 +4051,7 @@ def station_loop(ser, url, artist_hint=None, album_hint=None):
         refresh_main_menu(ser)
 
 
-PIDFILE = "/tmp/discstation.pid"
+PIDFILE = os.path.join(tempfile.gettempdir(), "discstation.pid")
 
 
 def check_pidfile():
@@ -3992,6 +4064,10 @@ def check_pidfile():
                 if sys.platform == "linux":
                     with open(f"/proc/{old_pid}/cmdline") as f:
                         alive = "discstation" in f.read()
+                elif os.name == "nt":
+                    tl = subprocess.run(["tasklist", "/FI", f"PID eq {old_pid}", "/FO", "CSV", "/NH"],
+                                        capture_output=True, text=True)
+                    alive = "python" in tl.stdout.lower()
                 else:
                     ps = subprocess.run(["ps", "-p", str(old_pid), "-o", "command="],
                                         capture_output=True, text=True)

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)
@@ -1323,6 +1325,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 +1360,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 +1481,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 +1552,64 @@ 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 _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."""
+    send(ser, "STATUS:Burning...")
+    send(ser, "PROGRESS:0%")
+    cmd, kwargs = discstation_host.ps_cmd(script, *script_args)
+    proc = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True, **kwargs)
+    out_lines, last_pct = [], -1
+    try:
+        for line in iter_proc_or_cancel(proc, ser):
+            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 = pct
+                    send(ser, f"PROGRESS:{min(pct, 99)}%")
+    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")

package/src/discstation_host.py

@@ -98,6 +98,54 @@ 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)
+
+
+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."""
+    import json as _json
+    import time
+    global _win_info_cache
+    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 +188,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 +301,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)
@@ -451,6 +533,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/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 + '"'
+        }
+    }
+}

package/src/win/audio-toc.ps1

@@ -0,0 +1,43 @@
+# Read an audio CD's table of contents via IMAPI2 raw reader. Emits JSON:
+#   {"track_count":N,"leadout":L,"tracks":[o1,o2,...]}   (frame offsets, +150)
+# Usage: audio-toc.ps1 <drive e.g. D:>
+param([Parameter(Mandatory = $true)] [string] $Drive)
+
+$ErrorActionPreference = "Stop"
+. (Join-Path $PSScriptRoot "_json.ps1")
+
+function Get-Recorder([string]$letter) {
+    $master = New-Object -ComObject "IMAPI2.MsftDiscMaster2"
+    for ($i = 0; $i -lt $master.Count; $i++) {
+        $rec = New-Object -ComObject "IMAPI2.MsftDiscRecorder2"
+        $rec.InitializeDiscRecorder($master.Item($i))
+        foreach ($p in $rec.VolumePathNames) { if ($p -and $p.TrimEnd('\') -ieq $letter) { return $rec } }
+    }
+    throw "No optical recorder for $letter"
+}
+
+$rec = Get-Recorder $Drive
+$raw = New-Object -ComObject "IMAPI2.MsftDiscFormat2RawCD"
+$raw.Recorder = $rec
+$raw.ClientName = "DiscStation"
+
+$toc = $raw.ReadDiscInformation()   # not always present; fall through to raw TOC
+$fmt = New-Object -ComObject "IMAPI2.MsftDiscFormat2Data"
+$fmt.Recorder = $rec
+
+# MsftDiscFormat2RawCD.get_TocInformation() -> byte array of the raw TOC (MMC-3).
+$bytes = $raw.ReadTocInformation()
+# TOC header: [0..1]=data length, [2]=first track, [3]=last track.
+$first = $bytes[2]; $last = $bytes[3]
+$offsets = @()
+$leadout = 0
+for ($i = 4; $i + 7 -lt $bytes.Length; $i += 8) {
+    $trk = $bytes[$i + 2]
+    # LBA is big-endian in bytes [i+4..i+7]
+    $lba = ($bytes[$i+4] -shl 24) -bor ($bytes[$i+5] -shl 16) -bor ($bytes[$i+6] -shl 8) -bor $bytes[$i+7]
+    if ($trk -eq 0xAA) { $leadout = $lba + 150 }
+    elseif ($trk -ge $first -and $trk -le $last) { $offsets += ($lba + 150) }
+}
+if ($offsets.Count -eq 0) { Write-Error "no audio tracks in TOC"; exit 2 }
+
+Write-Output (ConvertTo-JsonCompat @{ track_count = $offsets.Count; leadout = $leadout; tracks = $offsets })

package/src/win/burn-audio.ps1

@@ -0,0 +1,72 @@
+# Burn an audio CD (Red Book) from a folder of 16-bit / 44.1 kHz stereo WAV
+# files via IMAPI2 Track-At-Once. Streams "PROGRESS:<pct>".
+# Usage: burn-audio.ps1 <drive e.g. D:> <wav folder> [speed]
+param(
+    [Parameter(Mandatory = $true)] [string] $Drive,
+    [Parameter(Mandatory = $true)] [string] $WavDir,
+    [string] $Speed = ""
+)
+
+$ErrorActionPreference = "Stop"
+$wavs = @(Get-ChildItem -LiteralPath $WavDir -Filter *.wav | Sort-Object Name)
+if ($wavs.Count -eq 0) { Write-Error "no WAV files in $WavDir"; exit 2 }
+
+function Get-Recorder([string]$letter) {
+    $master = New-Object -ComObject "IMAPI2.MsftDiscMaster2"
+    for ($i = 0; $i -lt $master.Count; $i++) {
+        $rec = New-Object -ComObject "IMAPI2.MsftDiscRecorder2"
+        $rec.InitializeDiscRecorder($master.Item($i))
+        foreach ($p in $rec.VolumePathNames) {
+            if ($p -and $p.TrimEnd('\') -ieq $letter) { return $rec }
+        }
+    }
+    throw "No optical recorder for $letter"
+}
+
+$rec = Get-Recorder $Drive
+$fmt = New-Object -ComObject "IMAPI2.MsftDiscFormat2TrackAtOnce"
+if (-not $fmt.IsRecorderSupported($rec)) { Write-Error "recorder not supported"; exit 3 }
+$fmt.Recorder = $rec
+$fmt.ClientName = "DiscStation"
+try { $fmt.NumberOfExistingTracks } catch {}
+if ($Speed -and $Speed -match '^\d+') {
+    try { $fmt.SetWriteSpeed([int]($Speed -replace '\D',''), $false) } catch {}
+}
+
+$prepared = @()
+foreach ($w in $wavs) {
+    # IMAPI2 wants raw 44100/16/2 PCM. Strip the 44-byte WAV header.
+    $bytes = [System.IO.File]::ReadAllBytes($w.FullName)
+    $offset = 44
+    $idx = -1
+    for ($i = 12; $i -lt [Math]::Min($bytes.Length - 8, 4096); $i++) {
+        if ($bytes[$i] -eq 0x64 -and $bytes[$i+1] -eq 0x61 -and $bytes[$i+2] -eq 0x74 -and $bytes[$i+3] -eq 0x61) {
+            $offset = $i + 8; break
+        }
+    }
+    $raw = New-Object byte[] ($bytes.Length - $offset)
+    [Array]::Copy($bytes, $offset, $raw, 0, $raw.Length)
+    $prepared += ,@{ name = $w.Name; data = $raw }
+}
+
+$total = $prepared.Count
+$done = 0
+try {
+    foreach ($t in $prepared) {
+        $stream = New-Object -ComObject "ADODB.Stream"
+        $stream.Type = 1; $stream.Open()
+        $stream.Write($t.data)
+        $stream.Position = 0
+        $fmt.AddAudioTrack($stream)
+        $stream.Close()
+        $done++
+        Write-Output ("PROGRESS:" + [int]([math]::Min(99, $done * 100.0 / $total)))
+    }
+    $fmt.Close()
+    $fmt.Recorder.EjectMedia()
+    Write-Output "PROGRESS:100"
+    exit 0
+} catch {
+    Write-Error ("audio burn failed: " + $_.Exception.Message)
+    exit 1
+}

package/src/win/burn-data.ps1

@@ -0,0 +1,71 @@
+# Build a data-disc filesystem image from a folder (or single file) and burn it
+# via IMAPI2 - no external mkisofs needed. Streams "PROGRESS:<pct>".
+# Usage: burn-data.ps1 <drive e.g. D:> <source folder-or-file> <label> [speed]
+param(
+    [Parameter(Mandatory = $true)] [string] $Drive,
+    [Parameter(Mandatory = $true)] [string] $Source,
+    [Parameter(Mandatory = $true)] [string] $Label,
+    [string] $Speed = ""
+)
+
+$ErrorActionPreference = "Stop"
+if (-not (Test-Path $Source)) { Write-Error "source not found: $Source"; exit 2 }
+
+function Get-Recorder([string]$letter) {
+    $master = New-Object -ComObject "IMAPI2.MsftDiscMaster2"
+    for ($i = 0; $i -lt $master.Count; $i++) {
+        $rec = New-Object -ComObject "IMAPI2.MsftDiscRecorder2"
+        $rec.InitializeDiscRecorder($master.Item($i))
+        foreach ($p in $rec.VolumePathNames) {
+            if ($p -and $p.TrimEnd('\') -ieq $letter) { return $rec }
+        }
+    }
+    throw "No optical recorder for $letter"
+}
+
+$rec = Get-Recorder $Drive
+$fmt = New-Object -ComObject "IMAPI2.MsftDiscFormat2Data"
+if (-not $fmt.IsRecorderSupported($rec)) { Write-Error "recorder not supported"; exit 3 }
+$fmt.Recorder = $rec
+$fmt.ClientName = "DiscStation"
+if ($Speed -and $Speed -match '^\d+') {
+    try { $fmt.SetWriteSpeed([int]($Speed -replace '\D',''), $false) } catch {}
+}
+
+# Filesystem image: ISO9660 + Joliet + UDF, sized to the loaded media.
+$fsi = New-Object -ComObject "IMAPI2FS.MsftFileSystemImage"
+try { $fsi.ChooseImageDefaultsForMediaType($fmt.CurrentPhysicalMediaType) } catch {}
+$fsi.FileSystemsToCreate = 7          # ISO9660 | Joliet | UDF
+$fsi.VolumeName = ($Label -replace '[^A-Za-z0-9_\- ]', '').Substring(0, [Math]::Min(32, ($Label -replace '[^A-Za-z0-9_\- ]', '').Length))
+$fsi.FreeMediaBlocks = -1            # -1 = use the whole disc
+
+$item = Get-Item -LiteralPath $Source
+if ($item.PSIsContainer) {
+    foreach ($child in Get-ChildItem -LiteralPath $Source) { $fsi.Root.AddTree($child.FullName, $false) }
+} else {
+    $fsi.Root.AddTree($item.FullName, $false)
+}
+
+$result = $fsi.CreateResultImage()
+$stream = $result.ImageStream
+
+Register-ObjectEvent -InputObject $fmt -EventName "Update" -SourceIdentifier "burn" -Action {
+    $s = $EventArgs
+    try {
+        $done = [double]$s.LastWrittenLba
+        $tot  = [double]$s.SectorCount
+        if ($tot -gt 0) { Write-Output ("PROGRESS:" + [int]([math]::Min(99, $done * 100.0 / $tot))) }
+    } catch {}
+} | Out-Null
+
+try {
+    $fmt.Write($stream)
+    Write-Output "PROGRESS:100"
+    exit 0
+} catch {
+    Write-Error ("burn failed: " + $_.Exception.Message)
+    exit 1
+} finally {
+    Unregister-Event -SourceIdentifier "burn" -ErrorAction SilentlyContinue
+    try { $rec.EjectMedia() } catch {}
+}

package/src/win/burn-image.ps1

@@ -0,0 +1,64 @@
+# Burn a pre-built ISO to the optical drive via IMAPI2. Streams "PROGRESS:<pct>"
+# lines to stdout. Usage: burn-image.ps1 <drive e.g. D:> <iso path> [speed]
+param(
+    [Parameter(Mandatory = $true)] [string] $Drive,
+    [Parameter(Mandatory = $true)] [string] $Iso,
+    [string] $Speed = ""
+)
+
+$ErrorActionPreference = "Stop"
+if (-not (Test-Path $Iso)) { Write-Error "ISO not found: $Iso"; exit 2 }
+
+function Get-Recorder([string]$letter) {
+    $master = New-Object -ComObject "IMAPI2.MsftDiscMaster2"
+    for ($i = 0; $i -lt $master.Count; $i++) {
+        $rec = New-Object -ComObject "IMAPI2.MsftDiscRecorder2"
+        $rec.InitializeDiscRecorder($master.Item($i))
+        foreach ($p in $rec.VolumePathNames) {
+            if ($p -and $p.TrimEnd('\') -ieq $letter) { return $rec }
+        }
+    }
+    throw "No optical recorder for $letter"
+}
+
+$rec = Get-Recorder $Drive
+$fmt = New-Object -ComObject "IMAPI2.MsftDiscFormat2Data"
+if (-not $fmt.IsRecorderSupported($rec)) { Write-Error "recorder not supported"; exit 3 }
+$fmt.Recorder = $rec
+$fmt.ClientName = "DiscStation"
+try { $fmt.ForceMediaToBeClosed = $true } catch {}
+if ($Speed -and $Speed -match '^\d+') {
+    try { $fmt.SetWriteSpeed([int]($Speed -replace '\D',''), $false) } catch {}
+}
+
+# Progress: IMAPI2 raises an Update event with sector counts.
+$script:total = 1
+Register-ObjectEvent -InputObject $fmt -EventName "Update" -SourceIdentifier "burn" -Action {
+    $s = $EventArgs
+    try {
+        $done = [double]$s.LastWrittenLba
+        $tot  = [double]$s.SectorCount
+        if ($tot -gt 0) {
+            $pct = [int]([math]::Min(99, $done * 100.0 / $tot))
+            Write-Output "PROGRESS:$pct"
+        }
+    } catch {}
+} | Out-Null
+
+$stream = New-Object -ComObject "ADODB.Stream"
+$stream.Type = 1          # binary
+$stream.Open()
+$stream.LoadFromFile($Iso)
+
+try {
+    $fmt.Write($stream)
+    Write-Output "PROGRESS:100"
+    exit 0
+} catch {
+    Write-Error ("burn failed: " + $_.Exception.Message)
+    exit 1
+} finally {
+    $stream.Close()
+    Unregister-Event -SourceIdentifier "burn" -ErrorAction SilentlyContinue
+    try { $rec.EjectMedia() } catch {}
+}

package/src/win/disc-info.ps1

@@ -0,0 +1,76 @@
+# Optical drive + media state for DiscStation. Emits one JSON line.
+# Works on PowerShell 2.0 (Win7) and later. Optional arg: a drive letter ("D:")
+# to force; otherwise the first optical drive is used.
+param([string]$Drive = "")
+
+$ErrorActionPreference = "Stop"
+. (Join-Path $PSScriptRoot "_json.ps1")
+
+$out = @{ drive = ""; media_loaded = $false; blank = $false; label = "";
+          fs = ""; media_type = ""; rewritable = $false; capacity_bytes = 0 }
+
+try {
+    $cd = @(Get-WmiObject Win32_CDROMDrive)
+    if ($Drive) { $cd = @($cd | Where-Object { $_.Drive -eq $Drive }) }
+    if ($cd.Count -eq 0) { Write-Output (ConvertTo-JsonCompat $out); exit 0 }
+    $d = $cd[0]
+    $out.drive = $d.Drive
+    # NOTE: [bool]"False" is $true in PowerShell (any non-empty string casts
+    # truthy) -- compare explicitly instead of casting.
+    $out.media_loaded = ($d.MediaLoaded -eq $true) -or ("$($d.MediaLoaded)" -eq "True")
+} catch { Write-Output (ConvertTo-JsonCompat $out); exit 0 }
+
+if (-not $out.media_loaded) { Write-Output (ConvertTo-JsonCompat $out); exit 0 }
+
+# Volume label + filesystem (WMI logical disk).
+try {
+    $ld = Get-WmiObject Win32_LogicalDisk -Filter ("DeviceID='" + $out.drive + "'")
+    if ($ld) {
+        if ($ld.VolumeName) { $out.label = $ld.VolumeName }
+        if ($ld.FileSystem) {
+            $fs = $ld.FileSystem.ToLower()
+            if ($fs -match "udf") { $out.fs = "udf" }
+            elseif ($fs -match "cdfs|iso9660") { $out.fs = "iso9660" }
+            else { $out.fs = $fs }
+        }
+        if ($ld.Size) { $out.capacity_bytes = [int64]$ld.Size }
+    }
+} catch {}
+
+# IMAPI2: physical media type, blank flag, recordable capacity.
+try {
+    $master = New-Object -ComObject "IMAPI2.MsftDiscMaster2"
+    for ($i = 0; $i -lt $master.Count; $i++) {
+        $rec = New-Object -ComObject "IMAPI2.MsftDiscRecorder2"
+        $rec.InitializeDiscRecorder($master.Item($i))
+        $match = $false
+        foreach ($p in $rec.VolumePathNames) { if ($p -and $p.TrimEnd('\') -ieq $out.drive) { $match = $true } }
+        if (-not $match) { continue }
+        $fmt = New-Object -ComObject "IMAPI2.MsftDiscFormat2Data"
+        if (-not $fmt.IsRecorderSupported($rec)) { break }
+        $fmt.Recorder = $rec
+        $fmt.ClientName = "DiscStation"
+        try { $out.blank = ($fmt.MediaHeuristicallyBlank -eq $true) } catch {}
+        try { if ($fmt.MediaPhysicallyBlank) { $out.blank = $true } } catch {}
+        try { $out.capacity_bytes = [int64]$fmt.TotalSectorsOnMedia * 2048 } catch {}
+        $t = 0; try { $t = [int]$fmt.CurrentPhysicalMediaType } catch {}
+        # IMAPI_MEDIA_PHYSICAL_TYPE
+        $map = @{ 1="cd-rom"; 2="cd-r"; 3="cd-rw"; 4="dvd-rom"; 5="dvd-r"; 6="dvd-ram";
+                  7="dvd+r"; 8="dvd+rw"; 9="dvd+r dl"; 10="dvd-r dl"; 12="dvd+rw dl";
+                  16="bd-rom"; 17="bd-r"; 18="bd-re" }
+        if ($map.ContainsKey($t)) { $out.media_type = $map[$t] }
+        if ($out.media_type -match "rw|ram|-re") { $out.rewritable = $true }
+        break
+    }
+} catch {}
+
+# An audio CD has readable media, no filesystem, and (usually) no IMAPI type.
+if (-not $out.fs -and -not $out.blank -and ($out.media_type -eq "" -or $out.media_type -match "^cd")) {
+    try {
+        $ld2 = Get-WmiObject Win32_CDROMDrive -Filter ("Drive='" + $out.drive + "'")
+        # Win32_CDROMDrive has no track info; treat "media loaded, no FS, not blank" as audio.
+        $out.media_type = "audio_cd"
+    } catch {}
+}
+
+Write-Output (ConvertTo-JsonCompat $out)

package/src/win/eject.ps1

@@ -0,0 +1,30 @@
+# Eject or close the optical tray via IMAPI2, with a Shell.Application fallback.
+# Usage: eject.ps1 <drive letter e.g. D:> [close]
+param([string]$Drive = "", [switch]$Close)
+
+$ErrorActionPreference = "Stop"
+$ok = $false
+
+try {
+    $master = New-Object -ComObject "IMAPI2.MsftDiscMaster2"
+    for ($i = 0; $i -lt $master.Count; $i++) {
+        $rec = New-Object -ComObject "IMAPI2.MsftDiscRecorder2"
+        $rec.InitializeDiscRecorder($master.Item($i))
+        $match = -not $Drive
+        foreach ($p in $rec.VolumePathNames) { if ($p -and $Drive -and $p.TrimEnd('\') -ieq $Drive) { $match = $true } }
+        if (-not $match) { continue }
+        if ($Close) { $rec.CloseTray() } else { $rec.EjectMedia() }
+        $ok = $true
+        break
+    }
+} catch {}
+
+if (-not $ok -and -not $Close -and $Drive) {
+    try {
+        $sh = New-Object -ComObject "Shell.Application"
+        $sh.Namespace(17).ParseName($Drive).InvokeVerb("Eject")
+        $ok = $true
+    } catch {}
+}
+
+if ($ok) { exit 0 } else { Write-Error "eject failed"; exit 1 }