discstation 0.1.17 → 0.1.20

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)
@@ -1274,22 +1276,31 @@ def _run_growisofs(ser, growisofs_cmd, log_path, device=None):
 
 def _run_hdiutil_burn(ser, image_path, device=None):
     """Burn a pre-built ISO on macOS via `hdiutil burn -puppetstrings`, streaming
-    its PERCENT: lines to the ESP32."""
+    its PERCENT: lines to the ESP32 for both the write and verify passes."""
     send(ser, "STATUS:Burning image...")
     send(ser, "PROGRESS:0%")
     cmd = discstation_host.iso_burn_command(device or disc_device(), image_path)
+    if discstation_host.system_name() == "darwin":
+        # hdiutil block-buffers stdout to a pipe -> no progress until it exits.
+        # Run it under a pty (script relays the child's exit status verbatim).
+        cmd = ["/usr/bin/script", "-q", "/dev/null", *cmd]
     proc = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True)
     out_lines = []
     last_pct = -1
+    phase = "burn"
     try:
         for line in iter_proc_or_cancel(proc, ser):
             out_lines.append(line)
-            m = re.search(r"PERCENT:([\d.]+)", line)
-            if m:
-                pct = int(float(m.group(1)))
-                if 0 <= pct <= 100 and pct != last_pct:
-                    last_pct = pct
-                    send(ser, f"PROGRESS:{min(pct, 99)}%")
+            low = line.lower()
+            m = re.search(r"PERCENT:(-?[\d.]+)", line)
+            pct = int(float(m.group(1))) if m else None
+            if phase == "burn" and ("verif" in low or (pct is not None and last_pct > 90 and pct < 5)):
+                phase = "verify"
+                last_pct = -1
+                send(ser, "STATUS:Verifying...")
+            if pct is not None and 0 <= pct <= 100 and pct != last_pct:
+                last_pct = pct
+                send(ser, f"PROGRESS:{min(pct, 99)}%")
     except (KeyboardInterrupt, SystemExit):
         stop_process(proc)
         raise
@@ -1300,8 +1311,11 @@ def _run_hdiutil_burn(ser, image_path, device=None):
     safe_send(ser, "PROGRESS:100%")
     try:
         discstation_host.eject_device(device or disc_device())
-    except Exception as e:
-        print(f"Disc eject skipped: {e}")
+    except Exception:
+        try:
+            discstation_host.eject_device(None)  # device-less `drutil eject`
+        except Exception as e:
+            print(f"Disc eject skipped: {e}")
 
 
 def burn(ser, dvd_dir, disc_label, speed=None, is_dual_layer=False):
@@ -1311,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
@@ -1338,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
@@ -1452,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
@@ -1512,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/static/app.js

@@ -77,6 +77,7 @@
     try {
       const response = await fetch("/disc-info", { cache: "no-store" });
       const info = await response.json();
+      if (info.busy) return;               // burn/rip in progress — keep current
       state.discBytes = Number(info.capacity_bytes || 0);
       state.discType = info.type || "none";
       renderSelection();
@@ -281,7 +282,7 @@
     setInterval(loadDiscInfo, 15000);
   }
 
-  if ("serviceWorker" in navigator) navigator.serviceWorker.register("/sw.js?v=7").catch(() => {});
+  if ("serviceWorker" in navigator) navigator.serviceWorker.register("/sw.js?v=8").catch(() => {});
   window.addEventListener("beforeinstallprompt", (event) => {
     event.preventDefault();
     const button = document.createElement("button");

package/src/static/index.html

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

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 {}
+}