serve-sim 0.1.44 → 0.1.45-beta.116.1

package/README.md

@@ -19,6 +19,7 @@ https://github.com/user-attachments/assets/fbf890f4-c8c7-4684-82be-d677b8a188f8
 - Swipe from the bottom to go home.
 - gestures like pinch to zoom by holding the option key.
 - Simulator logs are forwarded to the browser for browser-use MCP tools to read from.
+- Recent simulator actions are available in the browser tools panel and `serve-sim event-log`.
 - Drag and drop videos and images to add them to the simulator device. 
 - Keyboard commands and hot keys are forwarded to the simulator, including CMD+SHIFT+H to go home.
 - Apple Watch, iPad, and iOS support.
@@ -51,6 +52,7 @@ serve-sim ca-debug <option> <on|off> [-d udid]
                                       Toggle a CoreAnimation debug flag
                                       (blended|copies|misaligned|offscreen|slow-animations)
 serve-sim memory-warning [-d udid]    Simulate a memory warning
+serve-sim event-log [-d udid]         Show recent simulator events
 
 serve-sim camera <bundle-id> [-d udid] [source-options]
                                       Inject a synthetic camera feed and (re)launch the app
@@ -68,6 +70,11 @@ Options:
   -d, --detach        Spawn helper and exit (daemon mode)
   -q, --quiet         JSON-only output
       --no-preview    Skip the web UI; stream in foreground only
+      --panes <panes> Initially open preview panes: devices, tools, devtools,
+                      or none
+      --fit           Initially size the simulator to fit the preview viewport
+      --theme <theme> Set simulator appearance before opening the preview:
+                      light or dark
       --codec <codec> Stream codec for the preview UI: 'auto' (H.264 when the
                       browser can decode it) or 'mjpeg' (force software JPEG —
                       e.g. on VMs without H.264 encode)
@@ -94,6 +101,8 @@ serve-sim "iPhone 16 Pro"              # target a specific device
 serve-sim --detach                     # start a background helper, return JSON
 serve-sim --list                       # show running streams
 serve-sim --kill                       # stop all helpers
+serve-sim --panes devices,tools --fit  # start with selected panes open and fit the simulator
+serve-sim --theme dark                 # start the simulator in Dark Mode
 
 # Type text into the focused field
 serve-sim type "Hello, world!"

package/Sources/SimCameraHelper/main.m

@@ -931,11 +931,13 @@ int main(int argc, const char *argv[]) {
         }
         if (gAcceptSource) dispatch_source_cancel(gAcceptSource);
         if (gControlListenFd >= 0) { close(gControlListenFd); if (socketPath) unlink(socketPath); }
+        // Unlink the shm name before stopping capture sources: if a source
+        // teardown crashes, the name must not stay resolvable forever.
+        if (gShmName) shm_unlink(gShmName);
         StopPlaceholderSource();
         StopWebcamSource();
         StopVideoSource();
         ReleaseSurfaces();
-        if (gShmName) shm_unlink(gShmName);
         fprintf(stderr, "[serve-sim-camera] stopped\n");
         return 0;
     }

package/Sources/SimNative/CaptureEngine.swift

@@ -0,0 +1,219 @@
+import Foundation
+import CoreVideo
+import CoreMedia
+import os
+
+// The capture + encode engine, reused verbatim from SimStreamHelper. Replicates
+// main.swift's frameHandler: MJPEG always encodes while clients exist; H.264 runs
+// only while AVCC is active. Encoded bytes (JPEG, or natively-framed AVCC
+// envelopes) are handed back through a Swift closure on a native encode thread;
+// the node-swift binding (sim-module.swift) marshals them onto the JS thread via
+// a NodeAsyncQueue (threadsafe function).
+
+struct Frame: Identifiable {
+    let id = UUID()
+    let pixelBuffer: CVPixelBuffer
+}
+
+protocol FrameEncoder {
+    associatedtype Encoded
+    func encode(_ frame: Frame) async throws -> Encoded
+}
+
+protocol CaptureConsuming: Sendable {
+    // this is intentionally synchronous. CaptureEngine sends all frames to all consumers,
+    // and lets them handle internal backpressure as they see fit. if instead this were async
+    // (and CaptureEngine waited for all consumers to finish), a single bad consumer could
+    // jam up the entire pipeline.
+    func handleFrame(_ frame: Frame)
+}
+
+actor CaptureConsumer<E: FrameEncoder>: CaptureConsuming {
+    nonisolated let continuation: AsyncStream<Frame>.Continuation
+
+    init(
+        encoder: E,
+        onFrame: @escaping @isolated(any) (E.Encoded) async -> Void
+    ) {
+        let (stream, continuation) = AsyncStream.makeStream(
+            of: Frame.self,
+            // drop old frames if there's backpressure
+            bufferingPolicy: .bufferingNewest(1)
+        )
+        self.continuation = continuation
+        Task {
+            _ = onFrame.isolation
+            for await frame in stream {
+                do {
+                    let encoded = try await encoder.encode(frame)
+                    await onFrame(encoded)
+                } catch {
+                    print("error encoding frame: \(error)")
+                    continue
+                }
+            }
+        }
+    }
+
+    nonisolated func handleFrame(_ frame: Frame) {
+        continuation.yield(frame)
+    }
+
+    deinit { continuation.finish() }
+}
+
+actor CaptureEngine {
+    private enum Phase {
+        case unstarted
+        case starting
+        case running
+        case stopped
+    }
+
+    private let deviceUDID: String
+    private let frameCapture = FrameCapture()
+    private var phase = Phase.unstarted
+
+    // mjpeg is stateless so we can share a single encoder instance
+    private let mjpegEncoder = MJPEGEncoder()
+
+    private(set) var screenSize = Dimensions(width: 0, height: 0)
+    private var consumers = [UUID: CaptureConsuming]()
+
+    init(deviceUDID: String) {
+        self.deviceUDID = deviceUDID
+    }
+
+    func start() async throws {
+        guard phase == .unstarted else { return }
+        phase = .starting
+        // Latch `started` only after capture actually begins: if start() throws
+        // (e.g. device not booted), a later retry should still be allowed.
+        let (frames, frameContinuation) = AsyncStream.makeStream(
+            of: Frame.self,
+            // drop old frames if there's backpressure
+            bufferingPolicy: .bufferingNewest(1)
+        )
+        try await frameCapture.start(deviceUDID: deviceUDID) { pixelBuffer, _ in
+            frameContinuation.yield(Frame(pixelBuffer: pixelBuffer))
+        }
+        Task {
+            for await frame in frames {
+                handleFrame(frame)
+            }
+        }
+        phase = .running
+    }
+
+    private func addConsumer<E: FrameEncoder>(
+        encoder: E,
+        onFrame: sending @escaping @isolated(any) (E.Encoded) async -> Void
+    ) -> (@Sendable () async -> Void) {
+        let consumer = CaptureConsumer(encoder: encoder) { [weak self] encoded in
+            guard let self, await self.phase == .running else { return }
+            await onFrame(encoded)
+        }
+        let id = UUID()
+        consumers[id] = consumer
+        return { await self.removeConsumer(id) }
+    }
+
+    private func removeConsumer(
+        _ id: UUID
+    ) {
+        consumers.removeValue(forKey: id)
+    }
+
+    private func handleFrame(_ frame: Frame) {
+        guard phase == .running else { return }
+        screenSize = frame.pixelBuffer.dimensions
+        for consumer in consumers.values {
+            consumer.handleFrame(frame)
+        }
+    }
+
+    func addMJPEGConsumer(
+        onFrame: sending @escaping (Dimensions, Data) async -> Void
+    ) -> (@Sendable () async -> Void) {
+        return addConsumer(encoder: mjpegEncoder, onFrame: { [weak self] data in
+            guard let self else { return }
+            await onFrame(screenSize, data)
+        })
+    }
+
+    func addAVCCConsumer(
+        onFrame: sending @escaping (Dimensions, Data, Int32) async -> Void
+    ) -> (@Sendable () async -> Void) {
+        addConsumer(encoder: AVCCEncoder()) { [weak self] encoded in
+            let flagDescription: Int32 = 1 << 0
+            let flagKeyframe: Int32 = 1 << 1
+
+            guard let self else { return }
+            if let description = encoded.description {
+                await onFrame(
+                    screenSize,
+                    AVCCEnvelope.description(avcc: description),
+                    flagDescription,
+                )
+            }
+            switch encoded.kind {
+            case .keyframe:
+                await onFrame(
+                    screenSize,
+                    AVCCEnvelope.keyframe(avcc: encoded.avcc),
+                    flagKeyframe,
+                )
+            case .delta:
+                await onFrame(
+                    screenSize,
+                    AVCCEnvelope.delta(avcc: encoded.avcc),
+                    0,
+                )
+            }
+        }
+    }
+
+    func stop() {
+        if phase == .stopped { return }
+        phase = .stopped
+        Task { [frameCapture] in await frameCapture.stop() }
+        consumers.removeAll()
+    }
+}
+
+actor MJPEGEncoder: FrameEncoder {
+    private let videoEncoder = VideoEncoder(quality: 0.7)
+    private var lastImage: (UUID, Data)?
+
+    init() {}
+
+    func encode(_ frame: Frame) async throws -> Data {
+        if let (id, data) = lastImage, id == frame.id { return data }
+        let data = try await videoEncoder.encode(pixelBuffer: frame.pixelBuffer)
+        lastImage = (frame.id, data)
+        return data
+    }
+}
+
+actor AVCCEncoder: FrameEncoder {
+    private static let timeout: Duration = .milliseconds(500)
+
+    let h264Encoder = H264Encoder(fps: 60)
+    var forceKeyframe = true
+
+    init() {}
+
+    func encode(_ frame: Frame) async throws -> H264Encoder.Encoded {
+        // TODO: cancel after timeout using TaskGroup
+        let result = try await h264Encoder.encode(
+            frame.pixelBuffer,
+            forceKeyframe: forceKeyframe,
+        )
+        forceKeyframe = false
+        return result
+    }
+
+    deinit {
+        Task { [h264Encoder] in await h264Encoder.stop() }
+    }
+}

package/Sources/SimNative/FrameCapture.swift

@@ -12,14 +12,17 @@ import ObjectiveC
 /// for late-joining clients.
 ///
 /// Pipeline: IOSurface (shared memory) → CVPixelBuffer (zero-copy) → H.264 encode
-final class FrameCapture {
+actor FrameCapture {
+    private let queue = DispatchSerialQueue(label: "frame-capture", qos: .userInteractive)
+    nonisolated var unownedExecutor: UnownedSerialExecutor { queue.asUnownedSerialExecutor() }
+
+    private var photocopier = Photocopier()
     private var onFrame: ((CVPixelBuffer, CMTime) -> Void)?
     private var frameCount: UInt64 = 0
     private(set) var capturedWidth: Int = 0
     private(set) var capturedHeight: Int = 0
-    private var idleTimer: DispatchSourceTimer?
-    private let captureQueue = DispatchQueue(label: "frame-capture", qos: .userInteractive)
-    private var lastCaptureTimeMs: UInt64 = 0
+    private var idleTimer: Task<Void, Never>?
+    private var lastCaptureTime: ContinuousClock.Instant = .now
     private var lastSeeds: [ObjectIdentifier: UInt32] = [:]
     private var rewireTickCount: Int = 0
     /// Interval at which the idle timer re-emits the current frame even when
@@ -32,13 +35,13 @@ final class FrameCapture {
     ///    one subscriber is due for it — a late-joining relay subscriber on an
     ///    idle sim never gets a cached frame to show.
     /// Re-emitting at ~5 fps fixes both without meaningful CPU cost.
-    private static let idleIntervalMs: UInt64 = 200
+    private static let idleInterval: ContinuousClock.Duration = .milliseconds(200)
 
     private var descriptors: [NSObject] = []
-    private var callbackUUIDs: [ObjectIdentifier: NSUUID] = [:]
+    private var callbackUUIDs: [ObjectIdentifier: UUID] = [:]
     private var ioClient: NSObject?
 
-    func start(deviceUDID: String, onFrame: @escaping (CVPixelBuffer, CMTime) -> Void) throws {
+    func start(deviceUDID: String, onFrame: @escaping @Sendable (CVPixelBuffer, CMTime) -> Void) throws {
         self.onFrame = onFrame
 
         SimFrameworks.load()
@@ -156,70 +159,56 @@ final class FrameCapture {
 
     // MARK: - Frame callbacks via objc_msgSend
 
-    private func registerFrameCallbacks(desc: NSObject) throws {
-        let regSel = NSSelectorFromString("registerScreenCallbacksWithUUID:callbackQueue:frameCallback:surfacesChangedCallback:propertiesChangedCallback:")
+    private func registerFrameCallbacks(desc: AnyObject) throws {
+        let regSel = #selector(FramebufferDescriptor.registerScreenCallbacks)
         guard desc.responds(to: regSel) else {
             throw makeError(8, "Descriptor doesn't support registerScreenCallbacks")
         }
 
-        guard let msgSendPtr = dlsym(UnsafeMutableRawPointer(bitPattern: -2), "objc_msgSend") else {
-            throw makeError(9, "objc_msgSend not found")
-        }
-
-        typealias MsgSendFunc = @convention(c) (
-            AnyObject, Selector, AnyObject, AnyObject, AnyObject, AnyObject, AnyObject
-        ) -> Void
-        let msgSend = unsafeBitCast(msgSendPtr, to: MsgSendFunc.self)
-
-        let uuid = NSUUID()
+        let uuid = UUID()
         callbackUUIDs[ObjectIdentifier(desc)] = uuid
 
-        let frameCallback: @convention(block) () -> Void = { [weak self] in
-            self?.captureQueue.async { self?.captureFrame() }
-        }
-        let surfacesCallback: @convention(block) () -> Void = { [weak self] in
-            self?.captureQueue.async { self?.captureFrame() }
-        }
-        let propsCallback: @convention(block) () -> Void = {}
-
-        msgSend(
-            desc, regSel,
-            uuid, captureQueue as AnyObject,
-            frameCallback as AnyObject, surfacesCallback as AnyObject, propsCallback as AnyObject
+        desc.registerScreenCallbacks(
+            uuid: uuid,
+            callbackQueue: queue,
+            frameCallback: { [self] in assumeIsolated { $0.captureFrame() } },
+            surfacesChangedCallback: { [self] in assumeIsolated { $0.captureFrame() } },
+            propertiesChangedCallback: {}
         )
     }
 
     private func startIdleTimer() {
-        let timer = DispatchSource.makeTimerSource(queue: captureQueue)
-        timer.schedule(deadline: .now().advanced(by: .milliseconds(Int(Self.idleIntervalMs))),
-                       repeating: .milliseconds(Int(Self.idleIntervalMs)))
-        timer.setEventHandler { [weak self] in
-            guard let self else { return }
-            let nowMs = DispatchTime.now().uptimeNanoseconds / 1_000_000
-            if (nowMs - self.lastCaptureTimeMs) >= Self.idleIntervalMs {
-                self.captureFrame()
+        self.idleTimer = Task { [weak self] in
+            while !Task.isCancelled {
+                guard let self else { return }
+                await self.onIdleTimerTick()
+                try? await Task.sleep(for: Self.idleInterval)
             }
-            // Self-heal: if we've never captured a frame, the cached descriptor
-            // is likely stale. Re-wire the pipeline periodically (every ~1s)
-            // until frames start flowing.
-            if self.frameCount == 0 {
-                self.rewireTickCount += 1
-                if self.rewireTickCount % 5 == 0 {
-                    do {
-                        try self.wireUpFramebuffer()
-                    } catch {
-                        // Swallow — we'll try again on the next tick.
-                    }
+        }
+    }
+
+    private func onIdleTimerTick() {
+        let now = ContinuousClock.now
+        guard (now - self.lastCaptureTime) >= Self.idleInterval else { return }
+        self.captureFrame(force: true)
+        // Self-heal: if we've never captured a frame, the cached descriptor
+        // is likely stale. Re-wire the pipeline periodically (every ~1s)
+        // until frames start flowing.
+        if self.frameCount == 0 {
+            self.rewireTickCount += 1
+            if self.rewireTickCount % 5 == 0 {
+                do {
+                    try self.wireUpFramebuffer()
+                } catch {
+                    // Swallow — we'll try again on the next tick.
                 }
             }
         }
-        timer.resume()
-        self.idleTimer = timer
     }
 
     // MARK: - Frame capture
 
-    private func captureFrame() {
+    private func captureFrame(force: Bool = false) {
         guard let desc = pickBestDescriptor() else { return }
 
         let surfSel = NSSelectorFromString("framebufferSurface")
@@ -230,14 +219,11 @@ final class FrameCapture {
         // don't spend cycles re-encoding the same pixels back-to-back from the
         // frame-callback path. BUT: we must still re-emit at the idle floor
         // (~5 fps) so that downstream consumers keep seeing a live stream —
-        // see the `idleIntervalMs` doc-comment for why that matters.
+        // see the `idleInterval` doc-comment for why that matters.
         let key = ObjectIdentifier(desc)
         let seed = IOSurfaceGetSeed(surface)
-        let nowMs = DispatchTime.now().uptimeNanoseconds / 1_000_000
-        let sinceLastMs = nowMs &- lastCaptureTimeMs
         let seedChanged = lastSeeds[key] != seed
-        let idleRefreshDue = frameCount > 0 && sinceLastMs >= Self.idleIntervalMs
-        if frameCount > 0, !seedChanged, !idleRefreshDue { return }
+        if frameCount > 0, !seedChanged, !force { return }
         lastSeeds[key] = seed
 
         let w = IOSurfaceGetWidth(surface)
@@ -258,10 +244,11 @@ final class FrameCapture {
         )
         guard status == kCVReturnSuccess, let pb = pixelBuffer?.takeRetainedValue() else { return }
 
-        lastCaptureTimeMs = nowMs
+        lastCaptureTime = .now
         frameCount += 1
         let timestamp = CMTime(value: CMTimeValue(frameCount), timescale: 60)
-        onFrame?(pb, timestamp)
+        guard let copy = photocopier.copy(pb) else { return }
+        onFrame?(copy, timestamp)
     }
 
     func getScreenSize() -> (width: Int, height: Int)? {
@@ -308,3 +295,14 @@ final class FrameCapture {
         })
     }
 }
+
+@objc protocol FramebufferDescriptor {
+    @objc(registerScreenCallbacksWithUUID:callbackQueue:frameCallback:surfacesChangedCallback:propertiesChangedCallback:)
+    func registerScreenCallbacks(
+        uuid: UUID,
+        callbackQueue: DispatchQueue,
+        frameCallback: @convention(block) @escaping () -> Void,
+        surfacesChangedCallback: @convention(block) @escaping () -> Void,
+        propertiesChangedCallback: @convention(block) @escaping () -> Void
+    )
+}

package/Sources/SimNative/H264Encoder.swift

@@ -11,7 +11,10 @@ import VideoToolbox
 /// The incoming buffer wraps SimulatorKit's live framebuffer IOSurface, which
 /// SimulatorKit recycles in place — VT encodes asynchronously, so we deep-copy
 /// into a private pooled buffer before submitting to avoid a torn frame race.
-final class H264Encoder {
+actor H264Encoder {
+    let queue = DispatchSerialQueue(label: "h264-encoder", qos: .userInteractive)
+    nonisolated var unownedExecutor: UnownedSerialExecutor { queue.asUnownedSerialExecutor() }
+
     struct Encoded {
         /// avcC parameter-set blob — emitted once on the first IDR per session.
         let description: Data?
@@ -21,16 +24,11 @@ final class H264Encoder {
         enum Kind { case keyframe, delta }
     }
 
-    var onEncoded: ((Encoded) -> Void)?
-
-    private let lock = NSLock()
     private var session: VTCompressionSession?
-    private var pool: CVPixelBufferPool?
     private var width: Int32 = 0
     private var height: Int32 = 0
     private let fps: Int32
     private var bitrate: Int
-    private let stateQueue = DispatchQueue(label: "H264Encoder.state")
     private var emittedDescription = false
     private var frameCount: Int64 = 0
 
@@ -44,8 +42,7 @@ final class H264Encoder {
     }
 
     /// Submit a frame. Returns immediately; `onEncoded` fires on VT's queue.
-    func encode(_ source: CVPixelBuffer, forceKeyframe: Bool = false, completion: (() -> Void)? = nil) {
-        lock.lock()
+    func encode(_ source: CVPixelBuffer, forceKeyframe: Bool = false) async throws -> Encoded {
         let w = Int32(CVPixelBufferGetWidth(source))
         let h = Int32(CVPixelBufferGetHeight(source))
         if session == nil || w != width || h != height {
@@ -53,10 +50,8 @@ final class H264Encoder {
             height = h
             rebuildSession()
         }
-        guard let session, let copy = copyBuffer(source) else {
-            lock.unlock()
-            completion?()
-            return
+        guard let session else {
+            throw Errors.couldNotCreateSession
         }
 
         frameCount += 1
@@ -64,63 +59,39 @@ final class H264Encoder {
         let frameProps: NSDictionary? = forceKeyframe
             ? [kVTEncodeFrameOptionKey_ForceKeyFrame: kCFBooleanTrue!] as NSDictionary
             : nil
-        lock.unlock()
 
-        let status = VTCompressionSessionEncodeFrame(
-            session,
-            imageBuffer: copy,
-            presentationTimeStamp: pts,
-            duration: .invalid,
-            frameProperties: frameProps,
-            infoFlagsOut: nil
-        ) { [weak self] status, _, sampleBuffer in
-            defer { completion?() }
-            guard let self, status == noErr, let sb = sampleBuffer else { return }
-            if let encoded = self.extract(from: sb) { self.onEncoded?(encoded) }
-        }
-        if status != noErr {
-            completion?()
+        let buffer: CMSampleBuffer? = await withCheckedContinuation { continuation in
+            let status = VTCompressionSessionEncodeFrame(
+                session,
+                imageBuffer: source,
+                presentationTimeStamp: pts,
+                duration: .invalid,
+                frameProperties: frameProps,
+                infoFlagsOut: nil
+            ) { @Sendable status, _, sampleBuffer in
+                guard status == noErr, let sb = sampleBuffer else {
+                    continuation.resume(returning: nil)
+                    return
+                }
+                continuation.resume(returning: sb)
+            }
+            if status != noErr {
+                continuation.resume(returning: nil)
+            }
         }
+        guard let buffer else { throw Errors.encodingFailed }
+        return try extract(from: buffer)
     }
 
     func stop() {
-        lock.lock()
-        defer { lock.unlock() }
         if let session {
             VTCompressionSessionInvalidate(session)
             self.session = nil
         }
-        pool = nil
     }
 
     // MARK: - private
 
-    /// Deep-copy `source` (which wraps the recycled framebuffer IOSurface)
-    /// into a private pooled buffer that VT can hold past this call.
-    private func copyBuffer(_ source: CVPixelBuffer) -> CVPixelBuffer? {
-        guard let pool else { return nil }
-        var out: CVPixelBuffer?
-        guard CVPixelBufferPoolCreatePixelBuffer(kCFAllocatorDefault, pool, &out) == kCVReturnSuccess,
-              let dst = out else { return nil }
-
-        CVPixelBufferLockBaseAddress(source, .readOnly)
-        CVPixelBufferLockBaseAddress(dst, [])
-        defer {
-            CVPixelBufferUnlockBaseAddress(dst, [])
-            CVPixelBufferUnlockBaseAddress(source, .readOnly)
-        }
-        guard let src = CVPixelBufferGetBaseAddress(source),
-              let dstAddr = CVPixelBufferGetBaseAddress(dst) else { return nil }
-        let srcStride = CVPixelBufferGetBytesPerRow(source)
-        let dstStride = CVPixelBufferGetBytesPerRow(dst)
-        let rows = CVPixelBufferGetHeight(source)
-        let copyBytes = min(srcStride, dstStride)
-        for row in 0..<rows {
-            memcpy(dstAddr + row * dstStride, src + row * srcStride, copyBytes)
-        }
-        return dst
-    }
-
     private func rebuildSession() {
         if let session {
             VTCompressionSessionInvalidate(session)
@@ -173,43 +144,30 @@ final class H264Encoder {
         }
         VTCompressionSessionPrepareToEncodeFrames(sess)
         session = sess
-        stateQueue.sync {
-            emittedDescription = false
-        }
-
-        // Pool feeding the deep-copy; BGRA matches the framebuffer surface.
-        let attrs: [String: Any] = [
-            kCVPixelBufferPixelFormatTypeKey as String: kCVPixelFormatType_32BGRA,
-            kCVPixelBufferWidthKey as String: Int(width),
-            kCVPixelBufferHeightKey as String: Int(height),
-            kCVPixelBufferIOSurfacePropertiesKey as String: [:],
-        ]
-        var newPool: CVPixelBufferPool?
-        CVPixelBufferPoolCreate(kCFAllocatorDefault, nil, attrs as CFDictionary, &newPool)
-        pool = newPool
+        emittedDescription = false
     }
 
-    private func extract(from sample: CMSampleBuffer) -> Encoded? {
+    private func extract(from sample: CMSampleBuffer) throws -> Encoded {
         let isKeyframe = !notSync(sample)
-        guard let dataBuf = CMSampleBufferGetDataBuffer(sample) else { return nil }
+        guard let dataBuf = CMSampleBufferGetDataBuffer(sample) else {
+            throw Errors.invalidSampleBuffer
+        }
 
         var totalLength = 0
         var dataPointer: UnsafeMutablePointer<Int8>?
         guard CMBlockBufferGetDataPointer(
             dataBuf, atOffset: 0, lengthAtOffsetOut: nil,
             totalLengthOut: &totalLength, dataPointerOut: &dataPointer
-        ) == noErr, let dataPointer else { return nil }
+        ) == noErr, let dataPointer else {
+            throw Errors.invalidSampleBuffer
+        }
         let avcc = Data(bytes: dataPointer, count: totalLength)
 
         var description: Data?
         if isKeyframe, let format = CMSampleBufferGetFormatDescription(sample) {
             let nextDescription = avcCBlob(from: format)
-            let shouldEmit = stateQueue.sync { () -> Bool in
-                if emittedDescription { return false }
-                emittedDescription = nextDescription != nil
-                return nextDescription != nil
-            }
-            if shouldEmit {
+            if !emittedDescription && nextDescription != nil {
+                emittedDescription = true
                 description = nextDescription
             }
         }
@@ -258,4 +216,10 @@ final class H264Encoder {
         blob.append(contentsOf: pps)
         return blob
     }
+
+    enum Errors: Error {
+        case couldNotCreateSession
+        case encodingFailed
+        case invalidSampleBuffer
+    }
 }