test(io): aetherctl segverify - isolated per-segment decodability probe for #92

Deterministic, headless verifier for the #92 segmentation defect (and the
later fix). Starts the engine, fetches init.mp4 + each segment SEQUENTIALLY
from the loopback (sequential so the producer does not restart and re-anchor
a clean IRAP), and SW-decodes each segment IN ISOLATION (init.mp4 + that one
segment, fresh decoder). framesDecoded == 0 means the segment carries no
usable IRAP to start from, i.e. it is not independently decodable.

- AetherEngine+Probe: swDecodeProbe(data:formatHint:) overload reusing the
  existing decode loop over an in-memory DataIOReader.
- aetherctl: `segverify [--from N] [--count K] [--dump <dir>] <url>`.

Validated against ffmpeg as ground truth on synthetic HEVC fixtures:
ffmpeg's own HLS fMP4 segmenter yields independently-decodable segments
(init+seg1 -> 96 frames), AetherEngine's current segmenter does not
(init+seg1 -> 0-2 frames, "Could not find ref with POC 92"). The probe
reports this correctly. Notable: the defect is broader than open-GOP - it
hits closed-GOP-with-B-frames too, because the constant reorder delay pushes
every keyframe's DTS below its PTS, so the boundary IRAP lands in the
previous segment and the next segment starts mid-GOP.

Full suite green (XCTest 227, Swift Testing 268), strict-concurrency clean.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01XZTEfmztPE8hAdjHdBr9BH

Author: superuser404notfound

Sources/AetherEngine/AetherEngine+Probe.swift

@@ -99,7 +99,29 @@ extension AetherEngine {
         let demuxer = Demuxer()
         try demuxer.open(url: url, extraHeaders: options.httpHeaders)
         defer { demuxer.close() }
+        return try swDecodeProbeRun(demuxer: demuxer, maxPackets: maxPackets)
+    }
+
+    /// SW-decode an in-memory media blob (e.g. an HLS `init.mp4` + one fMP4 segment concatenation) with a
+    /// fresh decoder and no render target. Used by `aetherctl segverify` to test whether one segment is
+    /// independently decodable: `framesDecoded == 0` means the blob carries no usable IRAP to start from
+    /// (the #92 open-GOP defect, where the segment's IRAP landed in the previous segment).
+    public nonisolated static func swDecodeProbe(
+        data: Data,
+        formatHint: String? = "mp4",
+        maxPackets: Int = 200,
+        options: LoadOptions = .init()
+    ) throws -> SoftwareDecodeProbeResult {
+        let demuxer = Demuxer()
+        try demuxer.open(reader: DataIOReader(data: data), formatHint: formatHint)
+        defer { demuxer.close() }
+        return try swDecodeProbeRun(demuxer: demuxer, maxPackets: maxPackets)
+    }
 
+    private nonisolated static func swDecodeProbeRun(
+        demuxer: Demuxer,
+        maxPackets: Int
+    ) throws -> SoftwareDecodeProbeResult {
         let videoIdx = demuxer.videoStreamIndex
         guard videoIdx >= 0, let stream = demuxer.stream(at: videoIdx) else {
             throw AetherEngineError.noVideoStream

Sources/aetherctl/SegVerify.swift

@@ -0,0 +1,86 @@
+import Foundation
+import AetherEngine
+
+/// `aetherctl segverify <url> [--from N] [--count K]` — deterministic, headless #92 verifier.
+///
+/// Starts the engine, then fetches `init.mp4` plus each media segment SEQUENTIALLY from the loopback
+/// server (sequential on purpose: jumping straight to a deep segment triggers a producer restart whose
+/// keyframe gate re-anchors a clean IRAP, masking the defect). Each tested segment is SW-decoded IN
+/// ISOLATION (`init.mp4` + that one segment, fresh decoder, no predecessor). `framesDecoded == 0` means
+/// the segment carries no usable IRAP to start from, i.e. it is not independently decodable, which is
+/// exactly what AVPlayer hits on a fresh decode at a mid-stream open-GOP boundary (#92).
+func runSegVerify(url: URL, from: Int, count: Int, dvModeAvailable: Bool, dumpDir: String? = nil) -> Int32 {
+    setvbuf(stdout, nil, _IONBF, 0)   // unbuffered: progressive output survives a long-running run
+    print("segverify: starting engine for \(url.absoluteString)")
+    let engine = HLSVideoEngine(url: url, dvModeAvailable: dvModeAvailable)
+    let playbackURL: URL
+    do {
+        playbackURL = try engine.start()
+    } catch {
+        print("ERROR: engine.start failed: \(error)")
+        return 1
+    }
+    print("segverify: engine started, playlist=\(playbackURL.absoluteString)")
+    defer { engine.stop() }
+
+    guard var comps = URLComponents(url: playbackURL, resolvingAgainstBaseURL: false) else {
+        print("ERROR: cannot parse playback URL \(playbackURL)")
+        return 1
+    }
+    comps.path = ""
+    comps.query = nil
+    guard let base = comps.url else {
+        print("ERROR: cannot derive loopback base from \(playbackURL)")
+        return 1
+    }
+
+    let initData: Data
+    do {
+        initData = try Data(contentsOf: base.appendingPathComponent("init.mp4"))
+    } catch {
+        print("ERROR: fetch init.mp4 failed: \(error)")
+        return 1
+    }
+    print("init.mp4: \(initData.count) B  (loopback \(base.absoluteString))")
+
+    let last = from + count
+    var independent = 0
+    var tested = 0
+    for n in 0..<last {
+        let segData: Data
+        do {
+            // Sequential fetch advances the producer's consumer target; without it the producer parks.
+            segData = try Data(contentsOf: base.appendingPathComponent("seg\(n).mp4"))
+        } catch {
+            print("seg\(n): FETCH FAILED \(error)")
+            if n >= from { tested += 1 }
+            continue
+        }
+        guard n >= from else { continue }   // fetched only to keep production sequential; not decoded
+        tested += 1
+
+        var blob = initData
+        blob.append(segData)
+        if let dumpDir {
+            let p = "\(dumpDir)/segverify_seg\(n).mp4"
+            try? blob.write(to: URL(fileURLWithPath: p))
+            print("seg\(n): dumped \(blob.count) B -> \(p)")
+        }
+        do {
+            let r = try AetherEngine.swDecodeProbe(data: blob, formatHint: "mp4", maxPackets: 400)
+            let ok = r.framesDecoded > 0
+            if ok { independent += 1 }
+            var line = "seg\(n): \(segData.count) B  fed=\(r.packetsFedToDecoder) decoded=\(r.framesDecoded)"
+            line += "  -> \(ok ? "INDEPENDENT" : "NOT-INDEPENDENT")"
+            if !r.openSucceeded { line += "  (decoder open failed: \(r.openError ?? "?"))" }
+            print(line)
+        } catch {
+            print("seg\(n): PROBE ERROR \(error)")
+        }
+    }
+
+    print("---")
+    print("segverify: \(independent)/\(tested) segments independently decodable  [\(from)..<\(last)]")
+    if tested == 0 { return 1 }
+    return independent == tested ? 0 : 2
+}

Sources/aetherctl/main.swift

@@ -69,6 +69,8 @@ func printUsage() {
       aetherctl serve [--no-dv] <url>
       aetherctl validate [--no-dv] <url>
       aetherctl swdecode [--frames N] <url>
+      aetherctl segverify [--from N] [--count K] [--no-dv] [--dump <dir>] <url>
+                          (#92: SW-decode each segment in isolation; framesDecoded==0 => not independent)
       aetherctl disc-inspect <disc.iso>
       aetherctl dovitest <file>
       aetherctl extract [--at <sec>] [--snapshot] [--width <px>] [--loops <n>] <url>
@@ -232,6 +234,22 @@ if first == "dvr" {
     exit(runDVR(path: path, seconds: seconds, dvrWindow: dvrWin))
 }
 
+// #92 verifier: SW-decode each segment in isolation; framesDecoded==0 => not independently decodable.
+if first == "segverify" {
+    var rest = Array(args.dropFirst(2))
+    let fromIdx = takeIntFlag("--from", from: &rest) ?? 0
+    let count   = takeIntFlag("--count", from: &rest) ?? 12
+    let noDV    = takeFlag("--no-dv", from: &rest)
+    let dumpDir = takeStringFlag("--dump", from: &rest)
+    guard let urlArg = rest.first(where: { !$0.hasPrefix("--") }) else {
+        print("ERROR: segverify requires a <url> argument")
+        exit(64)
+    }
+    rest.removeAll { $0 == urlArg }
+    rejectStrayFlags(rest, subcommand: "segverify")
+    exit(runSegVerify(url: parseSourceURL(urlArg), from: fromIdx, count: count, dvModeAvailable: !noDV, dumpDir: dumpDir))
+}
+
 // Rapid-seek burst repro (issue #35).
 if first == "seektest" {
     var rest = Array(args.dropFirst(2))