@@ -7,6 +7,15 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+### Added
+
+- `stream-video --format h264` now works on iOS, not just Android: a native `FBVideoStream` H.264 Annex B passthrough copied straight to stdout with no host-side codec pass. On a booted iPhone 17 Pro this delivers ~24 fps at ~1.3 MB per 6 s, against the screenshot loop's ~4.1 fps at ~11 MB — roughly 5.9x the frame rate for an eighth of the bytes. It consumes exactly like the Android leg: `sim-use stream-video --format h264 --device $UDID | ffplay -f h264 -probesize 32 -fflags nobuffer -`. The top-level `stream-video` no longer rejects `h264` for iOS targets, so the only platform-exclusive format left is the experimental iOS-only `bgra`. (#132)
+
+### Changed
+
+- iOS `record-video` and `stream-video` now drive the same capture. Both build one `FBVideoStreamConfiguration.h264Capture(fps:quality:scale:)` and differ only in where the encoded bytes land — `record-video` into the shared `H264MuxingPipeline` → MP4 (the muxer Android has always used, and which was written for both), `stream-video` into stdout. Recording no longer goes through idb's separate in-process file writer. Output is equivalent: the MP4 stays a regular non-fragmented file that QuickTime, Finder and `GIFTranscoder` all read, `--fps` is still honoured as a constant rate, and the finalize path still survives a 100 ms-grace SIGTERM across repeated runs. Frame timestamps now come from host arrival time rather than the encoder's sample clock, which measures as ~6 ms of inter-frame jitter against the previous ~3 ms — both far inside a 33 ms frame at 30 fps. (#132)
+
+
 ### Fixed
 
 - The bundled skill preflight now rejects an older `sim-use` CLI before device discovery and prints the Homebrew upgrade command, instead of misdiagnosing newly documented device types as disconnected.
 
@@ -307,18 +307,22 @@ The output path goes to stdout; progress messages go to stderr.
 ### Video streaming & recording
 
 ```bash
-# MJPEG stream (cross-platform)
-sim-use stream-video --device $UDID --fps 10 --format mjpeg > stream.mjpeg
+# Native H.264 live stream (cross-platform) — the fastest path and the one to
+# reach for. iOS drives FBVideoStream at a constant --fps; Android is an adb
+# screenrecord passthrough at the device's native variable frame rate.
+# Neither pays a host-side codec pass. Preview it live in ffplay:
+sim-use stream-video --device $UDID --format h264 | \
+  ffplay -f h264 -probesize 32 -fflags nobuffer -
 
-# Pipe into ffmpeg
+# Or mux it straight to a file
+sim-use stream-video --device $UDID --format h264 | ffmpeg -f h264 -i - -c copy out.mp4
+
+# Screenshot-backed formats (deprecated — an order of magnitude slower and
+# larger than h264; use h264 unless you specifically need per-frame images)
+sim-use stream-video --device $UDID --fps 10 --format mjpeg > stream.mjpeg
 sim-use stream-video --device $UDID --fps 30 --format ffmpeg | \
   ffmpeg -f image2pipe -framerate 30 -i - -c:v libx264 -preset ultrafast out.mp4
 
-# Native H.264 live stream (Android-only): adb screenrecord passthrough —
-# variable frame rate, cheap, high quality. Preview it live in ffplay:
-sim-use stream-video --device emulator-5554 --format h264 | \
-  ffplay -f h264 -probesize 32 -fflags nobuffer -
-
 # Record MP4 directly (cross-platform)
 sim-use record-video --device $UDID --output recording.mp4            # 30 fps default
 sim-use record-video --device $UDID --fps 60 --output smooth.mp4      # up to 60 fps
@@ -330,6 +334,11 @@ sim-use record-video --device $UDID --format gif                      # sim-use-
 sim-use record-video --device $UDID --format gif --fps 15 --scale 0.4 --output demo.gif
 ```
 
+`record-video` and `stream-video --format h264` drive the *same* capture on
+iOS — one H.264 configuration, differing only in whether the encoded bytes are
+muxed into an MP4 or copied to stdout. Measured on a booted iPhone 17 Pro,
+`h264` streams ~24 fps at ~220 KB/s where `mjpeg` manages ~4 fps at ~1.9 MB/s.
+
 `record-video` captures a real H.264 stream and muxes it straight into the
 MP4 (passthrough — no per-frame screenshot re-encoding). iOS records at a
 constant `--fps` (default 30, max 60); Android records at the device's
 
@@ -10,15 +10,15 @@ import iOSSimBackend
 /// surface and resolves the target platform, then delegates to:
 ///
 ///   * `IOSSimStreamVideoCommand.execute()` for iOS Simulator UDIDs
-///     (screenshot-capture JPEG formats + the raw `bgra` FBVideoStream).
+///     (native `FBVideoStream` h264 passthrough and raw `bgra`, plus the
+///     deprecated screenshot-capture formats).
 ///   * `AndroidStreamVideoCommand.stream()` for adb serials (native
 ///     `screenrecord` h264 passthrough + screencap JPEG formats).
 struct StreamVideo: SimUseExecutableCommand {
-    /// Union of both backends' formats. `mjpeg` / `raw` / `ffmpeg` are
-    /// shared; `bgra` is iOS-only (raw FBVideoStream pixels) and `h264`
-    /// is Android-only for now (iOS H.264 passthrough is a separate
-    /// follow-up) — the platform mismatch cases fail with a pointer to
-    /// the right alternative.
+    /// Union of both backends' formats. `h264` and the deprecated
+    /// `mjpeg` / `raw` / `ffmpeg` are shared; `bgra` is iOS-only (raw
+    /// FBVideoStream pixels) and fails on Android with a pointer to the
+    /// right alternative.
     enum OutputFormat: String, ExpressibleByArgument, Codable {
         case mjpeg
         case raw
@@ -41,10 +41,10 @@ struct StreamVideo: SimUseExecutableCommand {
 
     @OptionGroup var device: DeviceOptions
 
-    @Option(help: "Output format: mjpeg, raw, ffmpeg (both platforms); bgra (iOS-only); h264 (Android-only). Default: mjpeg")
+    @Option(help: "Output format: h264 (native passthrough on both platforms — fastest, recommended); mjpeg, raw, ffmpeg (screenshot-backed, deprecated); bgra (iOS-only raw pixels). Default: mjpeg")
     var format: OutputFormat = .mjpeg
 
-    @Option(help: "Frames per second (1-30, default: 10). Ignored by --format h264 (native variable frame rate).")
+    @Option(help: "Frames per second (1-30, default: 10). On iOS --format h264 records at this constant rate; Android's h264 ignores it (native variable frame rate).")
     var fps: Int?
 
     @Option(help: "JPEG quality (1-100, default: 80)")
@@ -113,15 +113,15 @@ struct StreamVideo: SimUseExecutableCommand {
         }
     }
 
-    /// Map the top-level format onto the iOS backend's enum; nil for the
-    /// Android-only `h264`.
+    /// Map the top-level format onto the iOS backend's enum. Every format
+    /// has an iOS mapping; only `bgra` lacks an Android one.
     static func iosFormat(for format: OutputFormat) -> IOSSimStreamVideoCommand.OutputFormat? {
         switch format {
         case .mjpeg: return .mjpeg
         case .raw: return .raw
         case .ffmpeg: return .ffmpeg
         case .bgra: return .bgra
-        case .h264: return nil
+        case .h264: return .h264
         }
     }
 
@@ -138,9 +138,6 @@ struct StreamVideo: SimUseExecutableCommand {
     }
 
     private func executeIOSSim() async throws -> ExecutionResult {
-        guard Self.iosFormat(for: format) != nil else {
-            throw CLIError(errorDescription: "--format h264 is Android-only for now (iOS H.264 passthrough is a separate follow-up). Use record-video for an H.264 file, or mjpeg/raw/ffmpeg to stream.")
-        }
         let sub = makeIOSSubcommand()
         let result = try await sub.execute()
         return ExecutionResult(
@@ -157,8 +154,8 @@ struct StreamVideo: SimUseExecutableCommand {
     /// `ForwarderInitializationGuardTests`.
     func makeIOSSubcommand() -> IOSSimStreamVideoCommand {
         var sub = IOSSimStreamVideoCommand()
-        // h264 has no iOS mapping and is rejected before this point; the
-        // fallback value keeps this constructor total for the guard test.
+        // Every top-level format maps to iOS; the fallback only keeps this
+        // constructor total.
         sub.format = Self.iosFormat(for: format) ?? .mjpeg
         sub.fps = fps ?? 10
         sub.quality = quality
 
@@ -0,0 +1,29 @@
+// SPDX-License-Identifier: Apache-2.0
+import Foundation
+@preconcurrency import FBControlCore
+import SimUseVideo
+
+/// Bridges idb's byte-stream consumer protocol to the shared Annex B → MP4
+/// muxer, letting an `FBSimulatorVideoStream` drive `H264MuxingPipeline`
+/// exactly as `adb screenrecord`'s stdout already does on Android — which is
+/// the arrangement that pipeline was written for.
+///
+/// idb delivers encoded bytes on its own capture queue. `ingest` parses and
+/// appends synchronously under the pipeline's lock, so the producer sees the
+/// same natural backpressure the Android path relies on.
+final class AnnexBPipelineConsumer: NSObject, FBDataConsumer {
+    private let pipeline: H264MuxingPipeline
+
+    init(pipeline: H264MuxingPipeline) {
+        self.pipeline = pipeline
+        super.init()
+    }
+
+    func consumeData(_ data: Data) {
+        pipeline.ingest(data)
+    }
+
+    func consumeEndOfFile() {
+        pipeline.finishIngest()
+    }
+}
@@ -0,0 +1,25 @@
+// SPDX-License-Identifier: Apache-2.0
+import Foundation
+@preconcurrency import FBControlCore
+
+extension FBVideoStreamConfiguration {
+    /// The H.264 capture configuration shared by `record-video` and
+    /// `stream-video`. Both verbs drive the identical framebuffer encode and
+    /// differ only in where the encoded bytes land — a muxed MP4 file or
+    /// stdout — so the configuration lives in one place rather than being
+    /// spelled out twice and drifting.
+    static func h264Capture(fps: Int, quality: Int, scale: Double) -> FBVideoStreamConfiguration {
+        FBVideoStreamConfiguration(
+            format: .compressedVideo(withCodec: .h264, transport: .annexB),
+            // Must be non-nil. With no frame rate idb selects a lazy cadence
+            // that pushes a frame only when the framebuffer reports damage,
+            // so a still screen would deliver nothing at all.
+            framesPerSecond: fps,
+            rateControl: .quality(Double(quality) / 100.0),
+            scaleFactor: scale,
+            // A 2 s keyframe interval bounds how long a consumer that joins
+            // mid-stream waits for its first decodable picture.
+            keyFrameRate: 2.0
+        )
+    }
+}
@@ -167,38 +167,51 @@ public struct IOSSimRecordVideoCommand: SimUseExecutableCommand {
         scale: Double,
         cancellationFlag: CancellationFlag
     ) async throws {
-        let config = FBVideoStreamConfiguration(
-            format: .compressedVideo(withCodec: .h264, transport: .annexB),
-            framesPerSecond: fps,
-            rateControl: .quality(Double(quality) / 100.0),
-            scaleFactor: scale,
-            keyFrameRate: 2.0
-        )
+        let config = FBVideoStreamConfiguration.h264Capture(fps: fps, quality: quality, scale: scale)
+
+        let recorder = try H264PassthroughRecorder(outputURL: outputURL)
+        var recorderFinalized = false
+        defer { if !recorderFinalized { recorder.invalidate() } }
+
+        let fatalBox = FirstErrorBox()
+        let pipeline = H264MuxingPipeline(recorder: recorder, onFatalError: { error in
+            fatalBox.set(error)
+            cancellationFlag.cancel()
+        })
 
-        let recording: any FBVideoRecording
+        let stream: any FBVideoStream
         do {
-            recording = try await simulator.startRecording(toFile: outputURL.path, configuration: config)
+            stream = try await simulator.createStream(
+                configuration: config,
+                to: AnnexBPipelineConsumer(pipeline: pipeline)
+            )
         } catch {
             throw RecordingUnavailableError(underlying: error.localizedDescription)
         }
 
-        while !(Task.isCancelled || cancellationFlag.isCancelled()) {
+        while !(Task.isCancelled || cancellationFlag.isCancelled() || fatalBox.first != nil) {
             try? await cancellableSleep(seconds: 0.1, flag: cancellationFlag)
         }
 
+        // Stopping the stream is best-effort: a stream that already died
+        // fails here with a secondary error that would mask the fatal one
+        // the pipeline latched, and the frames it did deliver are already in
+        // the recorder either way.
+        try? await stream.stopStreaming()
+        pipeline.finishIngest()
+
         do {
-            _ = try await recording.stop()
+            try await recorder.finish(stopHostTime: ProcessInfo.processInfo.systemUptime)
+            recorderFinalized = true
         } catch {
-            // Whether a usable file survived a mid-recording failure is not
-            // knowable from here (idb owns finalization internally) — check
-            // the filesystem directly rather than guessing, matching the
-            // Android branch's "partial recording saved" wording so the
-            // caller doesn't discard a usable recording on faith alone.
+            if let fatal = fatalBox.first { throw fatal }
             if FileManager.default.fileExists(atPath: outputURL.path) {
                 throw CLIError(errorDescription: "\(error.localizedDescription); partial recording saved to \(outputURL.path)")
             }
             throw error
         }
+
+        if let fatal = fatalBox.first { throw fatal }
     }
 
     // MARK: - Screenshot fallback