Fastest and only macOS Dictation app with on-device STT and custom trained AI enhancement model. Windows, iOS testflight! Android, Linux waitlist open! A local Wispr Flow alternative. Follow https://x.com/fluidvoiceapp for more
Fix media pause and resume during dictation (#957)
ALTIC9db0631a15d7
diff --git a/Sources/Fluid/Services/ASRService.swift b/Sources/Fluid/Services/ASRService.swiftindex b8445da5..1dda788c 100644--- a/Sources/Fluid/Services/ASRService.swift+++ b/Sources/Fluid/Services/ASRService.swift@@ -519,6 +519,7 @@ final class ASRService: ObservableObject {private(set) var dictionaryTrainingAudioGeneration = 0@Published private(set) var isStarting: Bool = false // Guard against re-entrant start() calls+ private var pendingMediaCaptureSessionID: Int?private var audioCaptureStartWaiters: [CheckedContinuation<Void, Never>] = []var isRunningOrStarting: Bool {self.isRunning || self.isStarting@@ -622,6 +623,8 @@ final class ASRService: ObservableObject {func shutdownForTermination() async {self.isTerminating = true+ // Give media restoration the same quit window as audio cleanup.+ MediaPlaybackService.shared.beginShutdown()let routeRecoveryShutdownStartedAt = Date().timeIntervalSince1970await self.cancelAudioRouteRecoveryAndWait()self.benchmarkLog(@@ -665,6 +668,7 @@ final class ASRService: ObservableObject {self.isAsrReady = falseself.isLoadingModel = falseself.isDownloadingModel = false+ await MediaPlaybackService.shared.shutdown()}/// The transcription provider, selected based on the unified SpeechModel setting.@@ -1460,10 +1464,6 @@ final class ASRService: ObservableObject {private var isEngineTapInstalled = falseprivate var isRecoveringAudioRoute = false- /// Tracks whether we paused system media for this recording session.- /// Used to resume playback only if we were the ones who paused it.- private var didPauseMediaForThisSession: Bool = false-private var audioLevelSubject = PassthroughSubject<CGFloat, Never>()var audioLevelPublisher: AnyPublisher<CGFloat, Never> {self.audioLevelSubject.eraseToAnyPublisher()@@ -2106,8 +2106,6 @@ final class ASRService: ObservableObject {// alive; startConfiguredAudioCapture reuses it for zero-stop first PCM.let handedOffMicrophonePreview = self.handOffMicrophonePreviewToCaptureStartIfNeeded()- // Reset media pause state for this session- self.didPauseMediaForThisSession = falseself.audioEngineStandbyTask?.cancel()self.audioEngineStandbyTask = nilawait self.waitForPendingAudioRouteRecoveryBeforeStart()@@ -2139,6 +2137,15 @@ final class ASRService: ObservableObject {self.streamingHealthLastBufferCount = 0self.silentPCMRecoveryWatchdog = AudioCaptureIdlePolicy.SilentPCMRecoveryWatchdog()let captureSessionID = self.benchmarkSessionID+ // Start media work alongside microphone startup; never await it on the+ // capture path. Track only this start so cancelling a buffer-handoff wait+ // cannot finish the previous session's still-running transcription.+ self.pendingMediaCaptureSessionID = captureSessionID+ defer { self.pendingMediaCaptureSessionID = nil }+ MediaPlaybackService.shared.recordingStarted(+ sessionID: captureSessionID,+ enabled: SettingsStore.shared.pauseMediaDuringTranscription+ )self.audioCaptureAttemptID &+= 1var readinessAttemptID = self.audioCaptureAttemptIDself.audioCaptureReadinessGate.arm(@@ -2359,23 +2366,6 @@ final class ASRService: ObservableObject {)onCaptureStarted?()- // Pause only after capture is live so media control cannot delay the- // first PCM packet. A quick stop while this await is in flight is- // handled explicitly below.- if SettingsStore.shared.pauseMediaDuringTranscription {- let didPause = await MediaPlaybackService.shared.pauseIfPlaying()- guard self.isRunning, self.isStoppingFinalTranscription == false else {- if didPause {- await MediaPlaybackService.shared.resumeIfWePaused(true)- }- return .started- }- self.didPauseMediaForThisSession = didPause- if didPause {- DebugLogger.shared.info("🎵 Paused system media for transcription", source: "ASRService")- }- }-// Direct capture already owns a required device-liveness listener// on its off-main lifecycle queue.if self.activeAudioCaptureBackend == .audioEngine,@@ -2401,6 +2391,7 @@ final class ASRService: ObservableObject {DebugLogger.shared.info("✅ START() completed successfully", source: "ASRService")return .started} catch {+ MediaPlaybackService.shared.sessionFinished(sessionID: captureSessionID)await self.audioCaptureReadinessGate.cancel(sessionID: captureSessionID,attemptID: readinessAttemptID@@ -2426,13 +2417,6 @@ final class ASRService: ObservableObject {DebugLogger.shared.error("Failed to start ASR session: \(error)", source: "ASRService")}- // Resume media if we paused it before the failure- if self.didPauseMediaForThisSession {- await MediaPlaybackService.shared.resumeIfWePaused(true)- self.didPauseMediaForThisSession = false- DebugLogger.shared.info("🎵 Resumed system media after start failure", source: "ASRService")- }-guard wasCancelled == false else { return .failed }AppServices.shared.microphonePreferenceCoordinator.markActiveSelectionUnavailable()@@ -2563,6 +2547,9 @@ final class ASRService: ObservableObject {func cancelPendingAudioCaptureStart(reason: String) async {guard self.isStarting, self.isRunning == false else { return }self.audioCaptureStartGeneration &+= 1+ if let sessionID = self.pendingMediaCaptureSessionID {+ MediaPlaybackService.shared.sessionFinished(sessionID: sessionID)+ }// A start waiting for the previous session's PCM handoff must wake to// observe the generation change; the old stop keeps ownership of the gate.self.recordingBufferHandoffGate.releasePendingWaiters()@@ -2723,6 +2710,8 @@ final class ASRService: ObservableObject {DebugLogger.shared.warning("STOP() ignored - recording buffer handoff already active", source: "ASRService")return ""}+ MediaPlaybackService.shared.recordingStopped(sessionID: stoppingSessionID)+ defer { MediaPlaybackService.shared.sessionFinished(sessionID: stoppingSessionID) }self.isStoppingFinalTranscription = truevar completedBufferHandoff = falsedefer {@@ -2749,10 +2738,6 @@ final class ASRService: ObservableObject {return ""}- // Capture media pause state before we reset it, for resuming at the end- let shouldResumeMedia = self.didPauseMediaForThisSession- self.didPauseMediaForThisSession = false // Reset for next session-DebugLogger.shared.debug("📍 Preparing final transcription", source: "ASRService")// Freeze an exact acquisition boundary before stopping hardware. The@@ -2813,7 +2798,6 @@ final class ASRService: ObservableObject {self.beginStreamingDrainRecovery(sessionID: stoppingSessionID, token: bufferHandoffToken)completedBufferHandoff = true // Recovery owns the PCM handoff until real work ends.self.lastStopOutcome = .failed- if shouldResumeMedia { await MediaPlaybackService.shared.resumeIfWePaused(true) }self.benchmarkLog("stop_end result=error reason=streaming_drain_timeout")return ""}@@ -2847,10 +2831,6 @@ final class ASRService: ObservableObject {"Final ASR result | provider=\(self.transcriptionProvider.name) | samples=0 | textChars=0 | confidence=nil | reason=no_audio",source: "ASRService")- if shouldResumeMedia {- await MediaPlaybackService.shared.resumeIfWePaused(true)- DebugLogger.shared.info("🎵 Resumed system media after empty audio", source: "ASRService")- }self.benchmarkLog("stop_end result=empty totalMs=\(self.elapsedMilliseconds(since: stopStartedAt)) reason=no_audio")return ""}@@ -2878,10 +2858,6 @@ final class ASRService: ObservableObject {"Final ASR result | provider=\(self.transcriptionProvider.name) | samples=\(pcm.count) | textChars=0 | confidence=nil | reason=short_silence",source: "ASRService")- if shouldResumeMedia {- await MediaPlaybackService.shared.resumeIfWePaused(true)- DebugLogger.shared.info("🎵 Resumed system media after silent audio", source: "ASRService")- }self.benchmarkLog("stop_end result=empty totalMs=\(self.elapsedMilliseconds(since: stopStartedAt)) reason=short_silence")@@ -2926,11 +2902,6 @@ final class ASRService: ObservableObject {guard provider.isReady else {DebugLogger.shared.error("Transcription provider is not ready", source: "ASRService")self.lastStopOutcome = .failed- // Resume media playback if we paused it- if shouldResumeMedia {- await MediaPlaybackService.shared.resumeIfWePaused(true)- DebugLogger.shared.info("🎵 Resumed system media after provider not ready", source: "ASRService")- }self.benchmarkLog("stop_end result=empty totalMs=\(self.elapsedMilliseconds(since: stopStartedAt)) reason=provider_not_ready")return ""}@@ -3034,12 +3005,6 @@ final class ASRService: ObservableObject {)}- // Resume media playback if we paused it- if shouldResumeMedia {- await MediaPlaybackService.shared.resumeIfWePaused(true)- DebugLogger.shared.info("🎵 Resumed system media after transcription", source: "ASRService")- }-self.lastStopOutcome = outputText.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty? .empty: .success@@ -3068,12 +3033,6 @@ final class ASRService: ObservableObject {// (e.g., accidental hotkey press) and would disrupt the user's workflow.// Errors are logged for debugging purposes.- // Resume media playback if we paused it- if shouldResumeMedia {- await MediaPlaybackService.shared.resumeIfWePaused(true)- DebugLogger.shared.info("🎵 Resumed system media after transcription failure", source: "ASRService")- }-self.benchmarkLog("stop_end result=error totalMs=\(self.elapsedMilliseconds(since: stopStartedAt)) error=\(error.localizedDescription)")return ""}@@ -3285,6 +3244,8 @@ final class ASRService: ObservableObject {guard self.isRunning else { return }let stoppingSessionID = self.benchmarkSessionIDguard let bufferHandoffToken = self.recordingBufferHandoffGate.begin() else { return }+ MediaPlaybackService.shared.recordingStopped(sessionID: stoppingSessionID)+ defer { MediaPlaybackService.shared.sessionFinished(sessionID: stoppingSessionID) }var completedBufferHandoff = falsedefer {if completedBufferHandoff == false {@@ -3304,10 +3265,6 @@ final class ASRService: ObservableObject {return}- // Capture media pause state before we reset it, for resuming at the end- let shouldResumeMedia = self.didPauseMediaForThisSession- self.didPauseMediaForThisSession = false // Reset for next session-DebugLogger.shared.info("🛑 Stopping recording - releasing audio devices", source: "ASRService")// CRITICAL: Set isRunning to false FIRST to signal any in-flight chunks to abort early@@ -3330,7 +3287,6 @@ final class ASRService: ObservableObject {guard await self.drainActiveStreamingWork(sessionID: stoppingSessionID) else {self.beginStreamingDrainRecovery(sessionID: stoppingSessionID, token: bufferHandoffToken)completedBufferHandoff = true- if shouldResumeMedia { await MediaPlaybackService.shared.resumeIfWePaused(true) }return}@@ -3346,12 +3302,6 @@ final class ASRService: ObservableObject {self.isProcessingChunk = falseself.skipNextChunk = falseself.refreshWordBoostStatus()-- // Resume media playback if we paused it- if shouldResumeMedia {- await MediaPlaybackService.shared.resumeIfWePaused(true)- DebugLogger.shared.info("🎵 Resumed system media after stopping without transcription", source: "ASRService")- }}private func configureSession() throws {diff --git a/Sources/Fluid/Services/MediaPlaybackService.swift b/Sources/Fluid/Services/MediaPlaybackService.swiftindex 0b99208f..1e78992d 100644--- a/Sources/Fluid/Services/MediaPlaybackService.swift+++ b/Sources/Fluid/Services/MediaPlaybackService.swift@@ -1,244 +1,267 @@import Foundation-#if arch(arm64)-import MediaRemoteAdapter-#endif-#if arch(arm64)+/// One reconciler owns all media queries and commands. Recording events update+/// intent synchronously; they never wait for media control or delay first PCM.@MainActor-protocol MediaPlaybackControlling {- func getTrackInfo(_ onReceive: @escaping (TrackInfo?) -> Void)- func pause()- func play()-}+final class MediaPlaybackService {+ static let shared = MediaPlaybackService(transport: MediaPlaybackProcessTransport())-extension MediaController: MediaPlaybackControlling {}-#endif+ private struct Session {+ let id: Int+ var mayPause: Bool+ }-/// Service that wraps MediaRemoteAdapter's MediaController to provide-/// controlled pause/resume functionality during transcription.-///-/// This service ensures we only pause media if it's currently playing,-/// and only resume if we were the ones who paused it.-@MainActor-final class MediaPlaybackService {- #if arch(arm64)- typealias TimeoutScheduler = (- _ delay: TimeInterval,- _ action: @escaping @MainActor @Sendable () -> Void- ) -> Void+ private let transport: any MediaPlaybackTransport+ private let settle: @Sendable () async -> Void+ private let now: @Sendable () -> TimeInterval+ private var session: Session?+ private var revision: UInt64 = 0+ private var attemptedSession: Int?+ private var pausedTarget: MediaPlaybackSnapshot?+ private var worker: Task<Void, Never>?+ private var suspendedUntil: TimeInterval = 0+ private var isShuttingDown = false- /// The pinned adapter's two-second deadline can occupy roughly 2.1 seconds- /// in run-loop slices. Leave additional time for process and callback delivery.- static let nowPlayingQueryTimeoutSeconds: TimeInterval = 2.5+ init(+ transport: any MediaPlaybackTransport,+ settle: @escaping @Sendable () async -> Void = {+ try? await Task.sleep(nanoseconds: 150_000_000)+ },+ now: @escaping @Sendable () -> TimeInterval = { ProcessInfo.processInfo.systemUptime }+ ) {+ self.transport = transport+ self.settle = settle+ self.now = now+ }- private static let productionTimeoutScheduler: TimeoutScheduler = { delay, action in- DispatchQueue.main.asyncAfter(deadline: .now() + delay, execute: action)+ func recordingStarted(sessionID: Int, enabled: Bool) {+ guard !self.isShuttingDown else { return }+ self.session = enabled ? Session(id: sessionID, mayPause: true) : nil+ self.revision &+= 1+ self.log("recording_started session=\(sessionID) enabled=\(enabled)")+ self.wake()}- static let shared = MediaPlaybackService(- mediaController: MediaController(),- queryTimeoutSeconds: MediaPlaybackService.nowPlayingQueryTimeoutSeconds,- timeoutScheduler: MediaPlaybackService.productionTimeoutScheduler- )+ /// Prevent a slow query from issuing pause after the hotkey is released.+ /// A previously confirmed pause stays owned until transcription finishes.+ func recordingStopped(sessionID: Int) {+ guard self.session?.id == sessionID else { return }+ self.session?.mayPause = false+ self.revision &+= 1+ self.log("recording_stopped session=\(sessionID)")+ self.wake()+ }- private let mediaController: any MediaPlaybackControlling- private let queryTimeoutSeconds: TimeInterval- private let timeoutScheduler: TimeoutScheduler+ /// An older transcription finishing cannot resume a newer recording's media.+ func sessionFinished(sessionID: Int) {+ guard self.session?.id == sessionID else { return }+ self.session = nil+ self.revision &+= 1+ self.log("session_finished session=\(sessionID)")+ self.wake()+ }- /// Creates an isolated service with injectable dependencies for deterministic tests.- init(- mediaController: any MediaPlaybackControlling,- queryTimeoutSeconds: TimeInterval,- timeoutScheduler: @escaping TimeoutScheduler- ) {- self.mediaController = mediaController- self.queryTimeoutSeconds = queryTimeoutSeconds- self.timeoutScheduler = timeoutScheduler- }- #else- static let shared = MediaPlaybackService()-- private init() {}- #endif-- // MARK: - Public API-- #if arch(arm64)- /// Pauses system media playback if something is currently playing.- ///- /// - Returns: `true` if a pause request was issued, `false` if nothing was playing or- /// if we couldn't determine playback state. The media adapter does not acknowledge- /// command completion.- ///- /// - Note: Uses a local one-shot gate to protect against `MediaRemoteAdapter`- /// firing the `getTrackInfo` callback more than once, which would otherwise- /// crash with `EXC_BREAKPOINT` (SIGTRAP) due to double-resume of a- /// `CheckedContinuation`.- func pauseIfPlaying() async -> Bool {- return await withCheckedContinuation { continuation in- let queryStartedAt = DispatchTime.now().uptimeNanoseconds- let resumeLock = NSLock()- var didResume = false-- @MainActor- func elapsedMilliseconds() -> UInt64 {- (DispatchTime.now().uptimeNanoseconds - queryStartedAt) / 1_000_000- }+ func beginShutdown() {+ guard !self.isShuttingDown else { return }+ self.isShuttingDown = true+ self.session = nil+ self.revision &+= 1+ self.wake()+ }- @discardableResult- @MainActor- func resumeOnce(- _ value: Bool,- logDuplicate: Bool = true,- beforeResume: () -> Void = {}- ) -> Bool {- var shouldResume = false-- resumeLock.lock()- if !didResume {- didResume = true- shouldResume = true- }- resumeLock.unlock()-- guard shouldResume else {- if logDuplicate {- DebugLogger.shared.warning(- """- MediaPlaybackService: Suppressed late or duplicate media callback \- (elapsedMs: \(elapsedMilliseconds()))- """,- source: "MediaPlaybackService"- )- }- return false- }+ func shutdown() async {+ self.beginShutdown()+ await self.waitUntilSettled()+ }- beforeResume()- continuation.resume(returning: value)- return true- }+ /// Also used by deterministic tests; no continuous observer or polling task.+ func waitUntilSettled() async {+ while let worker = self.worker {+ await worker.value+ }+ }- self.timeoutScheduler(self.queryTimeoutSeconds) {- if resumeOnce(false, logDuplicate: false) {- DebugLogger.shared.warning(- """- MediaPlaybackService: Now Playing query timed out; leaving playback unchanged \- (elapsedMs: \(elapsedMilliseconds()))- """,- source: "MediaPlaybackService"- )+ private func wake() {+ guard self.worker == nil else { return }+ self.worker = Task { await self.reconcile() }+ }++ private func reconcile() async {+ while true {+ let observedRevision = self.revision+ if let session = self.session {+ if session.mayPause, self.attemptedSession != session.id {+ self.attemptedSession = session.id+ await self.pause(sessionID: session.id)}+ } else if let target = self.pausedTarget {+ await self.resume(target: target)}+ guard observedRevision != self.revision else {+ self.worker = nil+ return+ }+ }+ }- self.mediaController.getTrackInfo { [weak self] trackInfo in- guard let self = self else {- DebugLogger.shared.warning(- """- MediaPlaybackService: Service released before query completed \- (elapsedMs: \(elapsedMilliseconds()))- """,- source: "MediaPlaybackService"- )- resumeOnce(false)- return- }+ private func canPause(_ sessionID: Int) -> Bool {+ self.session?.id == sessionID && self.session?.mayPause == true+ }- // If no track info is available, nothing is playing- guard let trackInfo = trackInfo else {- DebugLogger.shared.debug(- """- MediaPlaybackService: No track info available, nothing to pause \- (elapsedMs: \(elapsedMilliseconds()))- """,- source: "MediaPlaybackService"- )- resumeOnce(false)- return- }+ private func pause(sessionID: Int) async {+ guard self.now() >= self.suspendedUntil else {+ self.log("pause_suppressed session=\(sessionID) reason=player_backoff")+ return+ }+ guard let before = await self.queryBeforePause(sessionID: sessionID) else { return }+ guard self.canPause(sessionID) else {+ self.log("pause_skipped session=\(sessionID) reason=stale_recording")+ return+ }+ if let owned = self.pausedTarget, owned.matches(before), before.isPlaying == false {+ self.log("pause_retained session=\(sessionID) reason=already_owned")+ return+ }+ // A player change or manual playback invalidates our previous ownership.+ self.pausedTarget = nil+ guard before.isPlaying == true else {+ self.log("pause_skipped session=\(sessionID) reason=not_known_playing")+ return+ }+ let result = await self.transport.send(.pause)+ self.logCommand(.pause, result: result, sessionID: sessionID)+ // Even a timed-out helper might have sent its command before exiting.+ // Observe state before deciding whether we own a pause to restore.+ if let paused = await self.verify(target: before, playing: false, context: "pause session=\(sessionID)") {+ self.pausedTarget = paused+ self.log("pause_verified session=\(sessionID)")+ } else {+ self.backOff(context: "pause session=\(sessionID)")+ }+ }- // Determine if media is currently playing- // Use isPlaying if available, otherwise check playbackRate- let isPlaying: Bool- if let playing = trackInfo.payload.isPlaying {- isPlaying = playing- } else {- // playbackRate of 1.0 typically means playing, 0.0 means paused- isPlaying = (trackInfo.payload.playbackRate ?? 0.0) > 0.0- }+ private func queryBeforePause(sessionID: Int) async -> MediaPlaybackSnapshot? {+ for attempt in 1...3 {+ guard self.canPause(sessionID) else { return nil }+ if let snapshot = await self.query(context: "before_pause session=\(sessionID) attempt=\(attempt)") {+ return snapshot+ }+ guard self.canPause(sessionID) else { return nil }+ if attempt < 3 { await self.settle() }+ }+ return nil+ }- // Log what we found- DebugLogger.shared.debug(- """- MediaPlaybackService: Track info received- - App: \(trackInfo.payload.applicationName ?? "Unknown")- - Bundle: \(trackInfo.payload.bundleIdentifier ?? "Unknown")- - Title: \(trackInfo.payload.title ?? "Unknown")- - isPlaying: \(trackInfo.payload.isPlaying?.description ?? "nil")- - playbackRate: \(trackInfo.payload.playbackRate?.description ?? "nil")- - Determined playing: \(isPlaying)- - elapsedMs: \(elapsedMilliseconds())- """,- source: "MediaPlaybackService"- )-- if isPlaying {- resumeOnce(true) {- DebugLogger.shared.info(- """- MediaPlaybackService: Media is playing, sending pause command \- (elapsedMs: \(elapsedMilliseconds()))- """,- source: "MediaPlaybackService"- )- self.mediaController.pause()- }- } else {- DebugLogger.shared.debug(- """- MediaPlaybackService: Media is not playing, no action needed \- (elapsedMs: \(elapsedMilliseconds()))- """,- source: "MediaPlaybackService"- )- resumeOnce(false)- }+ private func resume(target: MediaPlaybackSnapshot) async {+ // Retry a command only after fresh metadata confirms the same paused item.+ // Retain ownership while a new recording may inherit the pause.+ for attempt in 1...2 {+ guard let before = await self.queryBeforeResume() else {+ if self.session == nil { self.pausedTarget = nil }+ self.log("resume_skipped reason=unknown_player")+ return+ }+ guard self.session == nil else {+ self.log("resume_skipped reason=new_recording")+ return+ }+ guard target.matches(before), before.isPlaying == false else {+ self.pausedTarget = nil+ self.log("resume_skipped reason=player_item_or_state_changed")+ return+ }+ let result = await self.transport.send(.play)+ self.logCommand(.play, result: result, sessionID: nil)+ if await self.verify(target: before, playing: true, context: "resume") != nil {+ self.pausedTarget = nil+ self.log("resume_verified")+ return+ }+ guard self.session == nil else { return }+ // Quit is best-effort within the app's overall termination deadline.+ // Do not add another command cycle while shutdown is in progress.+ if self.isShuttingDown || attempt == 2 {+ self.pausedTarget = nil+ self.backOff(context: "resume")+ return}}}- /// Resumes media playback only if we were the ones who paused it.- ///- /// - Parameter wePaused: `true` if `pauseIfPlaying()` returned `true` for this session.- func resumeIfWePaused(_ wePaused: Bool) async {- guard wePaused else {- DebugLogger.shared.debug(- "MediaPlaybackService: We didn't pause media, not resuming",- source: "MediaPlaybackService"- )- return+ private func queryBeforeResume() async -> MediaPlaybackSnapshot? {+ // Retain confirmed ownership across brief metadata outages. Retry reads,+ // never playback commands; give up after three bounded helper calls.+ for attempt in 1...3 {+ guard self.session == nil else { return nil }+ if let snapshot = await self.query(context: "before_resume attempt=\(attempt)") {+ return snapshot+ }+ guard self.session == nil else { return nil }+ if self.isShuttingDown { return nil }+ if attempt < 3 { await self.settle() }}+ return nil+ }- DebugLogger.shared.info(- "MediaPlaybackService: Resuming media playback (we paused it)",- source: "MediaPlaybackService"- )+ private func verify(+ target: MediaPlaybackSnapshot, playing: Bool, context: String+ ) async -> MediaPlaybackSnapshot? {+ // Read at most twice; never retry a playback command blindly. This checks+ // reported state, not rendered video: Netflix can disagree with its UI.+ for attempt in 1...2 {+ if attempt > 1, self.isShuttingDown { break }+ await self.settle()+ guard let observed = await self.query(context: "verify_\(context) attempt=\(attempt)") else {+ continue+ }+ guard target.matches(observed) else {+ self.log("verification_failed context=\(context) reason=player_or_item_changed")+ return nil+ }+ if observed.isPlaying == playing { return observed }+ }+ self.log("verification_failed context=\(context) reason=state_not_confirmed")+ return nil+ }- // Use explicit play() command - never toggle- self.mediaController.play()+ private func query(context: String) async -> MediaPlaybackSnapshot? {+ let started = self.now()+ let result = await self.transport.query()+ let elapsed = Int((self.now() - started) * 1000)+ switch result {+ case let .snapshot(snapshot):+ self.log(+ "query context=\(context) elapsedMs=\(elapsed) " ++ "bundle=\(snapshot.bundleIdentifier) pid=\(snapshot.processID) " ++ "playing=\(snapshot.isPlaying.map(String.init) ?? "unknown") " ++ "hasTitle=\(snapshot.title != nil)"+ )+ return snapshot+ case let .unavailable(reason):+ self.log("query_unavailable context=\(context) elapsedMs=\(elapsed) reason=\(reason)")+ return nil+ }+ }++ private func backOff(context: String) {+ // A finite cooldown limits damage from hotkey spam against an unresponsive+ // player. The next recording after the cooldown performs a fresh query.+ self.suspendedUntil = self.now() + 10+ self.log("commands_suspended context=\(context) seconds=10")}- #else- // Intel Mac stub - media control not available- func pauseIfPlaying() async -> Bool {- DebugLogger.shared.debug(- "MediaPlaybackService: Not available on Intel Macs",- source: "MediaPlaybackService"- )- return false++ private func logCommand(+ _ command: MediaPlaybackCommand, result: MediaPlaybackCommandResult, sessionID: Int?+ ) {+ let status: String+ switch result {+ case .helperCompleted: status = "helper_completed_player_unconfirmed"+ case let .failed(reason): status = "failed:\(reason)"+ }+ self.log("command=\(command.rawValue) session=\(sessionID.map(String.init) ?? "none") result=\(status)")}- func resumeIfWePaused(_ wePaused: Bool) async {- // No-op on Intel+ private func log(_ message: String) {+ DebugLogger.shared.info("MEDIA_CONTROL \(message)", source: "MediaPlaybackService")}- #endif}diff --git a/Sources/Fluid/Services/MediaPlaybackTransport.swift b/Sources/Fluid/Services/MediaPlaybackTransport.swiftnew file mode 100644index 00000000..66fe9eaa--- /dev/null+++ b/Sources/Fluid/Services/MediaPlaybackTransport.swift@@ -0,0 +1,242 @@+import Foundation+#if arch(arm64)+import MediaRemoteAdapter+#endif++nonisolated struct MediaPlaybackSnapshot: Equatable, Sendable {+ let bundleIdentifier: String+ let processID: Int32+ let title: String?+ let isPlaying: Bool?++ // Safari exposes its WebKit media process, not a tab ID. This comparison+ // can reject a changed player/item, but cannot prove exact-tab identity.+ func matches(_ other: Self) -> Bool {+ self.bundleIdentifier == other.bundleIdentifier &&+ self.processID == other.processID && self.title == other.title+ }+}++nonisolated enum MediaPlaybackQueryResult: Sendable {+ case snapshot(MediaPlaybackSnapshot)+ case unavailable(String)+}++nonisolated enum MediaPlaybackCommand: String, Sendable {+ case pause+ case play+}++nonisolated enum MediaPlaybackCommandResult: Sendable {+ /// The helper exited successfully. This is NOT acknowledgement from the player.+ case helperCompleted+ case failed(String)+}++nonisolated protocol MediaPlaybackTransport: Sendable {+ nonisolated func query() async -> MediaPlaybackQueryResult+ nonisolated func send(_ command: MediaPlaybackCommand) async -> MediaPlaybackCommandResult+}++/// Uses the existing bundled bridge, but owns its process completion and output.+/// A serial queue plus a hard process deadline prevents overlapping commands,+/// unbounded helpers, and the adapter's exit-versus-output callback race.+final nonisolated class MediaPlaybackProcessTransport: MediaPlaybackTransport, @unchecked Sendable {+ private let queue = DispatchQueue(label: "media.playback.transport", qos: .utility)++ func query() async -> MediaPlaybackQueryResult {+ let result = await self.invoke("get")+ guard result.failure == nil else { return .unavailable(result.failure ?? "helper_failed") }+ return Self.decode(result.output)+ }++ func send(_ command: MediaPlaybackCommand) async -> MediaPlaybackCommandResult {+ let result = await self.invoke(command.rawValue)+ if let failure = result.failure { return .failed(failure) }+ return .helperCompleted+ }++ static func decode(_ output: Data) -> MediaPlaybackQueryResult {+ guard let text = String(data: output, encoding: .utf8) else {+ return .unavailable("invalid_utf8")+ }+ let trimmed = text.trimmingCharacters(in: .whitespacesAndNewlines)+ guard !trimmed.isEmpty else { return .unavailable("empty_output") }+ guard trimmed != "NIL", trimmed != "null" else { return .unavailable("no_media_reported") }+ guard let object = try? JSONSerialization.jsonObject(with: output) as? [String: Any],+ let payload = object["payload"] as? [String: Any]+ else { return .unavailable("invalid_payload") }+ let processID: Int32?+ if let value = payload["PID"] as? String {+ processID = Int32(value)+ } else {+ processID = (payload["PID"] as? NSNumber)?.int32Value+ }+ guard let bundle = payload["bundleIdentifier"] as? String, !bundle.isEmpty,+ let processID, processID > 0+ else { return .unavailable("missing_player_identity") }+ let playing: Bool?+ if let value = payload["isPlaying"] as? Bool {+ playing = value+ } else if let rate = payload["playbackRate"] as? Double {+ playing = rate > 0+ } else {+ playing = nil+ }+ return .snapshot(MediaPlaybackSnapshot(+ bundleIdentifier: bundle,+ processID: processID,+ title: payload["title"] as? String,+ isPlaying: playing+ ))+ }++ private func invoke(_ command: String) async -> MediaHelperResult {+ await withCheckedContinuation { continuation in+ self.queue.async {+ continuation.resume(returning: self.run(command))+ }+ }+ }++ private func run(_ command: String) -> MediaHelperResult {+ #if arch(arm64)+ let framework = Bundle(for: MediaController.self)+ guard let library = framework.executablePath,+ let resourceURL = Bundle.main.url(+ forResource: "MediaRemoteAdapter_MediaRemoteAdapter", withExtension: "bundle"+ ),+ let resources = Bundle(url: resourceURL),+ let script = resources.path(forResource: "run", ofType: "pl")+ else { return MediaHelperResult(output: Data(), failure: "bridge_resources_missing") }++ // Run the shipped script unchanged. For commands, keep its run loop alive+ // through one bounded query before exiting, as the original upstream does.+ // The returned state is not used as command acknowledgement.+ let wrapper = """+ my $script = shift @ARGV;+ my $command = $ARGV[1];+ do $script;+ die $@ if $@;+ main::get() if $command eq 'pause' || $command eq 'play';+ """+ return MediaHelperProcess.run(arguments: ["-e", wrapper, script, library, command])+ #else+ return MediaHelperResult(output: Data(), failure: "unsupported_architecture")+ #endif+ }+}++nonisolated struct MediaHelperResult: Sendable {+ let output: Data+ let failure: String?+}++/// Private process plumbing; never runs on the main actor.+nonisolated enum MediaHelperProcess {+ static func run(arguments: [String], timeout: TimeInterval = 1.0) -> MediaHelperResult {+ let process = Process()+ process.executableURL = URL(fileURLWithPath: "/usr/bin/perl")+ process.arguments = arguments+ let output = Pipe()+ let errors = Pipe()+ let outputBuffer = MediaHelperBuffer(limit: 4 * 1024 * 1024)+ let errorBuffer = MediaHelperBuffer(limit: 4096)+ process.standardOutput = output+ process.standardError = errors+ output.fileHandleForReading.readabilityHandler = { handle in outputBuffer.drain(handle) }+ errors.fileHandleForReading.readabilityHandler = { handle in errorBuffer.drain(handle) }+ defer {+ output.fileHandleForReading.readabilityHandler = nil+ errors.fileHandleForReading.readabilityHandler = nil+ try? output.fileHandleForReading.close()+ try? errors.fileHandleForReading.close()+ }+ do {+ try process.run()+ } catch {+ return MediaHelperResult(output: Data(), failure: "launch_failed:\(error.localizedDescription)")+ }+ let deadline = MediaHelperDeadline(process: process)+ let timeoutWork = DispatchWorkItem { deadline.expire() }+ DispatchQueue.global(qos: .utility).asyncAfter(deadline: .now() + timeout, execute: timeoutWork)+ process.waitUntilExit()+ let timedOut = deadline.finish()+ timeoutWork.cancel()+ output.fileHandleForReading.readabilityHandler = nil+ errors.fileHandleForReading.readabilityHandler = nil+ let data = outputBuffer.finish(output.fileHandleForReading)+ let stderr = errorBuffer.finish(errors.fileHandleForReading)+ if timedOut { return MediaHelperResult(output: data, failure: "helper_timeout") }+ if process.terminationStatus != 0 {+ let message = (String(bytes: stderr.prefix(512), encoding: .utf8) ?? "invalid_utf8")+ .replacingOccurrences(of: "\n", with: " ")+ return MediaHelperResult(output: data, failure: "helper_exit_\(process.terminationStatus):\(message)")+ }+ if outputBuffer.overflowed { return MediaHelperResult(output: Data(), failure: "output_limit") }+ return MediaHelperResult(output: data, failure: nil)+ }+}++private final nonisolated class MediaHelperDeadline: @unchecked Sendable {+ private let lock = NSLock()+ private let process: Process+ private var finished = false+ private var expired = false++ init(process: Process) { self.process = process }++ func expire() {+ self.lock.lock()+ defer { self.lock.unlock() }+ guard !self.finished, self.process.isRunning else { return }+ self.expired = true+ // This is our own one-shot Perl child, with no user state to flush.+ kill(self.process.processIdentifier, SIGKILL)+ }++ func finish() -> Bool {+ self.lock.lock()+ defer { self.lock.unlock() }+ self.finished = true+ return self.expired+ }+}++private final nonisolated class MediaHelperBuffer: @unchecked Sendable {+ private let lock = NSLock()+ private let limit: Int+ private var data = Data()+ private var didOverflow = false++ init(limit: Int) { self.limit = limit }++ var overflowed: Bool {+ self.lock.lock()+ defer { self.lock.unlock() }+ return self.didOverflow+ }++ func drain(_ handle: FileHandle) {+ self.lock.lock()+ defer { self.lock.unlock() }+ let chunk = handle.availableData+ if chunk.isEmpty { handle.readabilityHandler = nil }+ self.append(chunk)+ }++ func finish(_ handle: FileHandle) -> Data {+ self.lock.lock()+ defer { self.lock.unlock() }+ while let chunk = try? handle.read(upToCount: 16_384), !chunk.isEmpty {+ self.append(chunk)+ }+ return self.data+ }++ private func append(_ chunk: Data) {+ let remaining = self.limit - self.data.count+ if chunk.count > remaining { self.didOverflow = true }+ self.data.append(chunk.prefix(remaining))+ }+}diff --git a/Tests/FluidDictationIntegrationTests/MediaPlaybackServiceTests.swift b/Tests/FluidDictationIntegrationTests/MediaPlaybackServiceTests.swiftindex 63d727e0..f799754d 100644--- a/Tests/FluidDictationIntegrationTests/MediaPlaybackServiceTests.swift+++ b/Tests/FluidDictationIntegrationTests/MediaPlaybackServiceTests.swift@@ -1,215 +1,605 @@@testable import FluidVoice_Debugimport Foundation-#if arch(arm64)-import MediaRemoteAdapter-#endifimport XCTest-#if arch(arm64)@MainActorfinal class MediaPlaybackServiceTests: XCTestCase {- func testPlayingCallbackBeforeTimeoutRequestsPause() async throws {- let (service, controller, scheduler) = self.makeService()- let pauseTask = Task { await service.pauseIfPlaying() }+ func testVerifiedPauseAndResumeAreOrdered() async {+ let transport = FakeMediaPlaybackTransport([self.state(true), self.state(false), self.state(false), self.state(true)])+ let service = self.service(transport)+ service.recordingStarted(sessionID: 1, enabled: true)+ await service.waitUntilSettled()+ service.recordingStopped(sessionID: 1)+ service.sessionFinished(sessionID: 1)+ await service.waitUntilSettled()+ let commands = await transport.commands+ let maxInFlight = await transport.maximumInFlight+ XCTAssertEqual(commands, [.pause, .play])+ XCTAssertEqual(maxInFlight, 1)+ }++ func testUnavailableOrPausedMediaNeverStartsPlayback() async {+ for result in [MediaPlaybackQueryResult.unavailable("no_media"), self.state(false), self.state(nil)] {+ let transport = FakeMediaPlaybackTransport([result])+ let service = self.service(transport)+ service.recordingStarted(sessionID: 1, enabled: true)+ await service.waitUntilSettled()+ service.sessionFinished(sessionID: 1)+ await service.waitUntilSettled()+ let commands = await transport.commands+ XCTAssertTrue(commands.isEmpty)+ }+ }- await controller.waitUntilQueryRegistered()- XCTAssertEqual(scheduler.scheduledDelays, [2.5])- controller.complete(with: try self.makeTrackInfo(isPlaying: true, playbackRate: 1))+ func testInitialQueryRetriesTransientFailure() async {+ let transport = FakeMediaPlaybackTransport([+ .unavailable("temporary"), self.state(true), self.state(false),+ ])+ let service = self.service(transport)+ service.recordingStarted(sessionID: 1, enabled: true)+ await service.waitUntilSettled()+ let commands = await transport.commands+ XCTAssertEqual(commands, [.pause])+ }- let didPause = await pauseTask.value- XCTAssertTrue(didPause)- XCTAssertEqual(controller.pauseCallCount, 1)+ func testInitialQueryRetriesAreBounded() async {+ let transport = FakeMediaPlaybackTransport([+ .unavailable("temporary"), .unavailable("temporary"), .unavailable("temporary"),+ ])+ let service = self.service(transport)+ service.recordingStarted(sessionID: 1, enabled: true)+ await service.waitUntilSettled()+ let commands = await transport.commands+ let count = await transport.queryCount+ XCTAssertTrue(commands.isEmpty)+ XCTAssertEqual(count, 3)+ }- scheduler.advance(by: 2.5)- XCTAssertEqual(controller.pauseCallCount, 1)+ func testReleasedRecordingDoesNotRetryUnavailableInitialQuery() async {+ let transport = FakeMediaPlaybackTransport([])+ await transport.holdQuery(1)+ let service = self.service(transport)+ service.recordingStarted(sessionID: 1, enabled: true)+ await transport.waitForQuery(1)+ service.recordingStopped(sessionID: 1)+ await transport.releaseQuery(.unavailable("temporary"))+ await service.waitUntilSettled()+ let commands = await transport.commands+ let count = await transport.queryCount+ XCTAssertTrue(commands.isEmpty)+ XCTAssertEqual(count, 1)}- func testCallbackAfterFormerOneSecondBoundaryStillRequestsPause() async throws {- let (service, controller, scheduler) = self.makeService()- let pauseTask = Task { await service.pauseIfPlaying() }+ func testDisabledSettingDoesNoMediaIO() async {+ let transport = FakeMediaPlaybackTransport([])+ let service = self.service(transport)+ service.recordingStarted(sessionID: 1, enabled: false)+ await service.waitUntilSettled()+ let count = await transport.queryCount+ XCTAssertEqual(count, 0)+ }- await controller.waitUntilQueryRegistered()- XCTAssertEqual(scheduler.scheduledDelays, [MediaPlaybackService.nowPlayingQueryTimeoutSeconds])- XCTAssertGreaterThan(MediaPlaybackService.nowPlayingQueryTimeoutSeconds, 2)+ func testStopDuringQueryPreventsLatePause() async {+ let transport = FakeMediaPlaybackTransport([])+ await transport.holdQuery(1)+ let service = self.service(transport)+ service.recordingStarted(sessionID: 1, enabled: true)+ await transport.waitForQuery(1)+ service.recordingStopped(sessionID: 1)+ await transport.releaseQuery(self.state(true))+ await service.waitUntilSettled()+ let commands = await transport.commands+ XCTAssertTrue(commands.isEmpty)+ service.sessionFinished(sessionID: 1)+ await service.waitUntilSettled()+ }- scheduler.advance(by: 1.1)- controller.complete(with: try self.makeTrackInfo(isPlaying: true, playbackRate: 1))+ func testFailedStartDuringQueryNeverPauses() async {+ let transport = FakeMediaPlaybackTransport([])+ await transport.holdQuery(1)+ let service = self.service(transport)+ service.recordingStarted(sessionID: 1, enabled: true)+ await transport.waitForQuery(1)+ service.sessionFinished(sessionID: 1)+ await transport.releaseQuery(self.state(true))+ await service.waitUntilSettled()+ let commands = await transport.commands+ XCTAssertTrue(commands.isEmpty)+ }- let didPause = await pauseTask.value- XCTAssertTrue(didPause)- XCTAssertEqual(controller.pauseCallCount, 1)+ func testFailedStartDuringPauseRestoresPlaybackOnce() async {+ let transport = FakeMediaPlaybackTransport([self.state(true), self.state(false), self.state(false), self.state(true)])+ await transport.holdCommand(1)+ let service = self.service(transport)+ service.recordingStarted(sessionID: 1, enabled: true)+ await transport.waitForCommand(1)+ service.sessionFinished(sessionID: 1)+ service.sessionFinished(sessionID: 1)+ await transport.releaseCommand(.helperCompleted)+ await service.waitUntilSettled()+ let commands = await transport.commands+ let maxInFlight = await transport.maximumInFlight+ XCTAssertEqual(commands, [.pause, .play])+ XCTAssertEqual(maxInFlight, 1)+ }- scheduler.advance(by: 1.4)- XCTAssertEqual(controller.pauseCallCount, 1)+ func testNewRecordingSupersedesPendingQueryAndOldFinish() async {+ let transport = FakeMediaPlaybackTransport([self.state(true), self.state(false)])+ await transport.holdQuery(1)+ let service = self.service(transport)+ service.recordingStarted(sessionID: 1, enabled: true)+ await transport.waitForQuery(1)+ service.recordingStarted(sessionID: 2, enabled: true)+ service.sessionFinished(sessionID: 1)+ await transport.releaseQuery(self.state(true))+ await service.waitUntilSettled()+ let commands = await transport.commands+ let count = await transport.queryCount+ XCTAssertEqual(commands, [.pause])+ XCTAssertEqual(count, 3)}- func testTimeoutThenLatePlayingCallbackNeverPauses() async throws {- let (service, controller, scheduler) = self.makeService()- let pauseTask = Task { await service.pauseIfPlaying() }+ func testStopDuringPauseWaitsForConfirmationBeforeResume() async {+ let transport = FakeMediaPlaybackTransport([self.state(true), self.state(false), self.state(false), self.state(true)])+ await transport.holdCommand(1)+ let service = self.service(transport)+ service.recordingStarted(sessionID: 1, enabled: true)+ await transport.waitForCommand(1)+ service.recordingStopped(sessionID: 1)+ service.sessionFinished(sessionID: 1)+ let pendingCommands = await transport.commands+ XCTAssertEqual(pendingCommands, [.pause])+ await transport.releaseCommand(.helperCompleted)+ await service.waitUntilSettled()+ let commands = await transport.commands+ let maxInFlight = await transport.maximumInFlight+ XCTAssertEqual(commands, [.pause, .play])+ XCTAssertEqual(maxInFlight, 1)+ }- await controller.waitUntilQueryRegistered()- scheduler.advance(by: 2.5)+ func testNewRecordingDuringResumeQueryRetainsPause() async {+ let transport = FakeMediaPlaybackTransport([+ self.state(true), self.state(false), self.state(false), self.state(false), self.state(true),+ ])+ let service = self.service(transport)+ service.recordingStarted(sessionID: 1, enabled: true)+ await service.waitUntilSettled()+ await transport.holdQuery(3)+ service.sessionFinished(sessionID: 1)+ await transport.waitForQuery(3)+ service.recordingStarted(sessionID: 2, enabled: true)+ await transport.releaseQuery(self.state(false))+ await service.waitUntilSettled()+ let beforeFinish = await transport.commands+ XCTAssertEqual(beforeFinish, [.pause])+ service.sessionFinished(sessionID: 1)+ service.sessionFinished(sessionID: 2)+ await service.waitUntilSettled()+ let commands = await transport.commands+ XCTAssertEqual(commands, [.pause, .play])+ }- let didPause = await pauseTask.value- XCTAssertFalse(didPause)- XCTAssertEqual(controller.pauseCallCount, 0)+ func testFailedPlayRetriesOnlyAfterConfirmingSamePausedPlayer() async {+ let transport = FakeMediaPlaybackTransport([+ self.state(true), self.state(false), self.state(false), self.state(false), self.state(false),+ self.state(false), self.state(true),+ ])+ let service = self.service(transport)+ service.recordingStarted(sessionID: 1, enabled: true)+ await service.waitUntilSettled()+ service.sessionFinished(sessionID: 1)+ await service.waitUntilSettled()+ let commands = await transport.commands+ XCTAssertEqual(commands, [.pause, .play, .play])+ }- controller.complete(with: try self.makeTrackInfo(isPlaying: true, playbackRate: 1))- XCTAssertEqual(controller.pauseCallCount, 0)+ func testFailedPlayDoesNotRetryForChangedPlayer() async {+ let transport = FakeMediaPlaybackTransport([+ self.state(true), self.state(false), self.state(false), self.state(false), self.state(false),+ self.state(false, pid: 2),+ ])+ let service = self.service(transport)+ service.recordingStarted(sessionID: 1, enabled: true)+ await service.waitUntilSettled()+ service.sessionFinished(sessionID: 1)+ await service.waitUntilSettled()+ let commands = await transport.commands+ XCTAssertEqual(commands, [.pause, .play])}- func testDuplicatePlayingCallbacksIssueOnePause() async throws {- let (service, controller, _) = self.makeService()- let pauseTask = Task { await service.pauseIfPlaying() }- let playingTrack = try self.makeTrackInfo(isPlaying: true, playbackRate: 1)+ func testFailedPlayRetryIsBounded() async {+ let transport = FakeMediaPlaybackTransport([+ self.state(true), self.state(false), self.state(false), self.state(false), self.state(false),+ self.state(false), self.state(false), self.state(false),+ ])+ let service = self.service(transport)+ service.recordingStarted(sessionID: 1, enabled: true)+ await service.waitUntilSettled()+ service.sessionFinished(sessionID: 1)+ await service.waitUntilSettled()+ let commands = await transport.commands+ XCTAssertEqual(commands, [.pause, .play, .play])+ }- await controller.waitUntilQueryRegistered()- controller.complete(with: playingTrack, retainingCallback: true)- controller.complete(with: playingTrack)+ func testShutdownDuringPauseUsesOneVerificationPerCommand() async {+ let transport = FakeMediaPlaybackTransport([+ self.state(true), self.state(false), self.state(false), self.state(false),+ ])+ await transport.holdCommand(1)+ let service = self.service(transport)+ service.recordingStarted(sessionID: 1, enabled: true)+ await transport.waitForCommand(1)+ service.beginShutdown()+ service.beginShutdown()+ service.recordingStarted(sessionID: 2, enabled: true)+ await transport.releaseCommand(.helperCompleted)+ await service.shutdown()+ let commands = await transport.commands+ let count = await transport.queryCount+ XCTAssertEqual(commands, [.pause, .play])+ XCTAssertEqual(count, 4)+ }- let didPause = await pauseTask.value- XCTAssertTrue(didPause)- XCTAssertEqual(controller.pauseCallCount, 1)+ func testNewRecordingDuringFailedPlayRetainsPause() async {+ let transport = FakeMediaPlaybackTransport([+ self.state(true), self.state(false), self.state(false), self.state(false), self.state(false),+ self.state(false), self.state(false), self.state(true),+ ])+ let service = self.service(transport)+ service.recordingStarted(sessionID: 1, enabled: true)+ await service.waitUntilSettled()+ await transport.holdCommand(2)+ service.sessionFinished(sessionID: 1)+ await transport.waitForCommand(2)+ service.recordingStarted(sessionID: 2, enabled: true)+ await transport.releaseCommand(.failed("timeout"))+ await service.waitUntilSettled()+ let beforeFinish = await transport.commands+ XCTAssertEqual(beforeFinish, [.pause, .play])+ service.sessionFinished(sessionID: 2)+ await service.waitUntilSettled()+ let commands = await transport.commands+ XCTAssertEqual(commands, [.pause, .play, .play])}- func testPlaybackStateResolutionDoesNotPauseFalseCasesAndUsesRateFallback() async throws {- let nilResult = await self.pauseResult(for: nil)- XCTAssertFalse(nilResult.didPause)- XCTAssertEqual(nilResult.pauseCallCount, 0)+ func testShutdownDoesNotRetryUnavailableQuery() async {+ let transport = FakeMediaPlaybackTransport([+ self.state(true), self.state(false), .unavailable("temporary"),+ ])+ let service = self.service(transport)+ service.recordingStarted(sessionID: 1, enabled: true)+ await service.waitUntilSettled()+ await service.shutdown()+ let commands = await transport.commands+ let count = await transport.queryCount+ XCTAssertEqual(commands, [.pause])+ XCTAssertEqual(count, 3)+ }- let explicitlyPaused = await self.pauseResult(- for: try self.makeTrackInfo(isPlaying: false, playbackRate: 1)- )- XCTAssertFalse(explicitlyPaused.didPause)- XCTAssertEqual(explicitlyPaused.pauseCallCount, 0)+ func testTransientResumeQueryFailureRetriesBeforePlaying() async {+ let transport = FakeMediaPlaybackTransport([+ self.state(true), self.state(false), .unavailable("temporary"), self.state(false), self.state(true),+ ])+ let service = self.service(transport)+ service.recordingStarted(sessionID: 1, enabled: true)+ await service.waitUntilSettled()+ service.sessionFinished(sessionID: 1)+ await service.waitUntilSettled()+ let commands = await transport.commands+ XCTAssertEqual(commands, [.pause, .play])+ }- let zeroRate = await self.pauseResult(- for: try self.makeTrackInfo(isPlaying: nil, playbackRate: 0)- )- XCTAssertFalse(zeroRate.didPause)- XCTAssertEqual(zeroRate.pauseCallCount, 0)+ func testResumeQueryFailureStopsAfterBoundedRetries() async {+ let transport = FakeMediaPlaybackTransport([+ self.state(true), self.state(false), .unavailable("temporary"),+ .unavailable("temporary"), .unavailable("temporary"),+ ])+ let service = self.service(transport)+ service.recordingStarted(sessionID: 1, enabled: true)+ await service.waitUntilSettled()+ service.sessionFinished(sessionID: 1)+ await service.waitUntilSettled()+ let commands = await transport.commands+ let count = await transport.queryCount+ XCTAssertEqual(commands, [.pause])+ XCTAssertEqual(count, 5)+ }- let positiveRate = await self.pauseResult(- for: try self.makeTrackInfo(isPlaying: nil, playbackRate: 1)- )- XCTAssertTrue(positiveRate.didPause)- XCTAssertEqual(positiveRate.pauseCallCount, 1)+ func testResumeRetryDoesNotPlayChangedItem() async {+ let transport = FakeMediaPlaybackTransport([+ self.state(true), self.state(false), .unavailable("temporary"), self.state(false, title: "Other"),+ ])+ let service = self.service(transport)+ service.recordingStarted(sessionID: 1, enabled: true)+ await service.waitUntilSettled()+ service.sessionFinished(sessionID: 1)+ await service.waitUntilSettled()+ let commands = await transport.commands+ XCTAssertEqual(commands, [.pause])}- func testResumeOnlyPlaysWhenPauseOwnershipIsTrue() async {- let (service, controller, _) = self.makeService()+ func testNewRecordingDuringUnavailableResumeQueryRetainsPause() async {+ let transport = FakeMediaPlaybackTransport([+ self.state(true), self.state(false), self.state(false), self.state(false), self.state(true),+ ])+ let service = self.service(transport)+ service.recordingStarted(sessionID: 1, enabled: true)+ await service.waitUntilSettled()+ await transport.holdQuery(3)+ service.sessionFinished(sessionID: 1)+ await transport.waitForQuery(3)+ service.recordingStarted(sessionID: 2, enabled: true)+ await transport.releaseQuery(.unavailable("temporary"))+ await service.waitUntilSettled()+ let beforeFinish = await transport.commands+ XCTAssertEqual(beforeFinish, [.pause])+ service.sessionFinished(sessionID: 2)+ await service.waitUntilSettled()+ let commands = await transport.commands+ XCTAssertEqual(commands, [.pause, .play])+ }- await service.resumeIfWePaused(false)- XCTAssertEqual(controller.playCallCount, 0)+ func testUnconfirmedPauseDoesNotResumeOrSpamCommands() async {+ let transport = FakeMediaPlaybackTransport([self.state(true), self.state(true), self.state(true)])+ let service = self.service(transport)+ service.recordingStarted(sessionID: 1, enabled: true)+ await service.waitUntilSettled()+ service.sessionFinished(sessionID: 1)+ for id in 2...10 {+ service.recordingStarted(sessionID: id, enabled: true)+ await service.waitUntilSettled()+ service.sessionFinished(sessionID: id)+ }+ await service.waitUntilSettled()+ let commands = await transport.commands+ let count = await transport.queryCount+ XCTAssertEqual(commands, [.pause])+ XCTAssertEqual(count, 3)+ }- await service.resumeIfWePaused(true)- XCTAssertEqual(controller.playCallCount, 1)+ func testNewRecordingDuringPlayWaitsBeforePausingAgain() async {+ let transport = FakeMediaPlaybackTransport([+ self.state(true), self.state(false), self.state(false), self.state(true), self.state(true), self.state(false),+ ])+ let service = self.service(transport)+ service.recordingStarted(sessionID: 1, enabled: true)+ await service.waitUntilSettled()+ await transport.holdCommand(2)+ service.sessionFinished(sessionID: 1)+ await transport.waitForCommand(2)+ service.recordingStarted(sessionID: 2, enabled: true)+ service.sessionFinished(sessionID: 1)+ await transport.releaseCommand(.helperCompleted)+ await service.waitUntilSettled()+ let commands = await transport.commands+ let maxInFlight = await transport.maximumInFlight+ XCTAssertEqual(commands, [.pause, .play, .pause])+ XCTAssertEqual(maxInFlight, 1)}- private func makeService() -> (- service: MediaPlaybackService,- controller: FakeMediaPlaybackController,- scheduler: ManualTimeoutScheduler- ) {- let controller = FakeMediaPlaybackController()- let scheduler = ManualTimeoutScheduler()- let service = MediaPlaybackService(- mediaController: controller,- queryTimeoutSeconds: MediaPlaybackService.nowPlayingQueryTimeoutSeconds,- timeoutScheduler: scheduler.schedule- )- return (service, controller, scheduler)+ func testPauseRemainsOwnedUntilTranscriptionFinishes() async {+ let transport = FakeMediaPlaybackTransport([self.state(true), self.state(false), self.state(false), self.state(true)])+ let service = self.service(transport)+ service.recordingStarted(sessionID: 1, enabled: true)+ await service.waitUntilSettled()+ service.recordingStopped(sessionID: 1)+ await service.waitUntilSettled()+ let beforeFinish = await transport.commands+ XCTAssertEqual(beforeFinish, [.pause])+ service.sessionFinished(sessionID: 1)+ await service.waitUntilSettled()+ let commands = await transport.commands+ XCTAssertEqual(commands, [.pause, .play])}- private func pauseResult(for trackInfo: TrackInfo?) async -> (- didPause: Bool,- pauseCallCount: Int- ) {- let (service, controller, _) = self.makeService()- let pauseTask = Task { await service.pauseIfPlaying() }+ func testCooldownHasBoundedExit() async {+ let transport = FakeMediaPlaybackTransport([+ self.state(true), self.state(true), self.state(true), self.state(true), self.state(false),+ ])+ let clock = MediaTestClock()+ let service = MediaPlaybackService(transport: transport, settle: {}, now: { clock.value })+ service.recordingStarted(sessionID: 1, enabled: true)+ await service.waitUntilSettled()+ clock.advance(11)+ service.recordingStarted(sessionID: 2, enabled: true)+ await service.waitUntilSettled()+ let commands = await transport.commands+ XCTAssertEqual(commands, [.pause, .pause])+ }- await controller.waitUntilQueryRegistered()- controller.complete(with: trackInfo)+ func testChangedPlayerOrItemAndManualPlayAreNotResumed() async {+ for changed in [self.state(false, pid: 2), self.state(false, title: "Other"), self.state(true)] {+ let transport = FakeMediaPlaybackTransport([self.state(true), self.state(false), changed])+ let service = self.service(transport)+ service.recordingStarted(sessionID: 1, enabled: true)+ await service.waitUntilSettled()+ service.sessionFinished(sessionID: 1)+ await service.waitUntilSettled()+ let commands = await transport.commands+ XCTAssertEqual(commands, [.pause])+ }+ }- return (await pauseTask.value, controller.pauseCallCount)+ func testUnknownVerificationNeverClaimsOwnership() async {+ let transport = FakeMediaPlaybackTransport([+ self.state(true), .unavailable("timeout"), .unavailable("empty_output"),+ ])+ let service = self.service(transport)+ service.recordingStarted(sessionID: 1, enabled: true)+ await service.waitUntilSettled()+ service.sessionFinished(sessionID: 1)+ await service.waitUntilSettled()+ let commands = await transport.commands+ XCTAssertEqual(commands, [.pause])}- private func makeTrackInfo(isPlaying: Bool?, playbackRate: Double?) throws -> TrackInfo {- var payload: [String: Any] = [:]- if let isPlaying {- payload["isPlaying"] = isPlaying+ func testCommandTimeoutStillChecksForAppliedPause() async {+ let transport = FakeMediaPlaybackTransport([self.state(true), self.state(false), self.state(false), self.state(true)])+ await transport.holdCommand(1)+ let service = self.service(transport)+ service.recordingStarted(sessionID: 1, enabled: true)+ await transport.waitForCommand(1)+ await transport.releaseCommand(.failed("helper_timeout"))+ await service.waitUntilSettled()+ service.sessionFinished(sessionID: 1)+ await service.waitUntilSettled()+ let commands = await transport.commands+ XCTAssertEqual(commands, [.pause, .play])+ }++ func testShutdownRestoresConfirmedPauseAndRejectsNewStarts() async {+ let transport = FakeMediaPlaybackTransport([self.state(true), self.state(false), self.state(false), self.state(true)])+ let service = self.service(transport)+ service.recordingStarted(sessionID: 1, enabled: true)+ await service.waitUntilSettled()+ await service.shutdown()+ service.recordingStarted(sessionID: 2, enabled: true)+ await service.waitUntilSettled()+ let commands = await transport.commands+ XCTAssertEqual(commands, [.pause, .play])+ }++ func testRawQueryFailuresAreDistinct() {+ for (text, reason) in [("", "empty_output"), ("NIL\n", "no_media_reported"), ("{", "invalid_payload")] {+ guard case let .unavailable(actual) = MediaPlaybackProcessTransport.decode(Data(text.utf8)) else {+ return XCTFail("Expected unavailable: \(reason)")+ }+ XCTAssertEqual(actual, reason)}- if let playbackRate {- payload["playbackRate"] = playbackRate+ }++ func testRawQueryAcceptsMissingTitleAndDoesNotOverrideExplicitPause() {+ let text = #"{"payload":{"PID":"42","bundleIdentifier":"com.apple.WebKit.GPU","isPlaying":false,"playbackRate":1}}"#+ guard case let .snapshot(snapshot) = MediaPlaybackProcessTransport.decode(Data(text.utf8)) else {+ return XCTFail("Expected player state")}- let data = try JSONSerialization.data(withJSONObject: ["payload": payload])- return try JSONDecoder().decode(TrackInfo.self, from: data)+ XCTAssertEqual(snapshot.processID, 42)+ XCTAssertNil(snapshot.title)+ XCTAssertEqual(snapshot.isPlaying, false)}-}-@MainActor-private final class FakeMediaPlaybackController: MediaPlaybackControlling {- private var callback: ((TrackInfo?) -> Void)?- private var registrationWaiters: [CheckedContinuation<Void, Never>] = []- private(set) var pauseCallCount = 0- private(set) var playCallCount = 0+ func testProcessDrainsBothPipesBeforeCompletion() async {+ let result = await Task.detached {+ MediaHelperProcess.run(arguments: ["-e", "print 'x' x 200000; print STDERR 'y' x 200000;"])+ }.value+ XCTAssertNil(result.failure)+ XCTAssertEqual(result.output.count, 200_000)+ }- func getTrackInfo(_ onReceive: @escaping (TrackInfo?) -> Void) {- self.callback = onReceive- let waiters = self.registrationWaiters- self.registrationWaiters.removeAll()- waiters.forEach { $0.resume() }+ func testDefaultProcessTimeoutIsOneSecond() async {+ let started = ProcessInfo.processInfo.systemUptime+ let result = await Task.detached {+ MediaHelperProcess.run(arguments: ["-e", "sleep 10"])+ }.value+ XCTAssertEqual(result.failure, "helper_timeout")+ XCTAssertLessThan(ProcessInfo.processInfo.systemUptime - started, 2.0)}- func pause() {- self.pauseCallCount += 1+ func testProcessTimeoutTerminatesHelper() async {+ let result = await Task.detached {+ MediaHelperProcess.run(arguments: ["-e", "sleep 10;"], timeout: 0.1)+ }.value+ XCTAssertEqual(result.failure, "helper_timeout")}- func play() {- self.playCallCount += 1+ func testProcessOutputIsBounded() async {+ let result = await Task.detached {+ MediaHelperProcess.run(arguments: ["-e", "print 'x' x 5000000;"])+ }.value+ XCTAssertEqual(result.failure, "output_limit")+ XCTAssertTrue(result.output.isEmpty)}- func waitUntilQueryRegistered() async {- guard self.callback == nil else { return }- await withCheckedContinuation { continuation in- self.registrationWaiters.append(continuation)+ private func service(_ transport: FakeMediaPlaybackTransport) -> MediaPlaybackService {+ MediaPlaybackService(transport: transport, settle: {}, now: { 0 })+ }++ private func state(_ playing: Bool?, pid: Int32 = 1, title: String = "Netflix") -> MediaPlaybackQueryResult {+ .snapshot(MediaPlaybackSnapshot(bundleIdentifier: "com.apple.WebKit.GPU", processID: pid, title: title, isPlaying: playing))+ }+}++private actor FakeMediaPlaybackTransport: MediaPlaybackTransport {+ private var results: [MediaPlaybackQueryResult]+ private var heldQueryIndex: Int?+ private var heldCommandIndex: Int?+ private var queryContinuation: CheckedContinuation<MediaPlaybackQueryResult, Never>?+ private var commandContinuation: CheckedContinuation<MediaPlaybackCommandResult, Never>?+ private var queryWaiter: (Int, CheckedContinuation<Void, Never>)?+ private var commandWaiter: (Int, CheckedContinuation<Void, Never>)?+ private var inFlight = 0+ private(set) var maximumInFlight = 0+ private(set) var queryCount = 0+ private(set) var commands: [MediaPlaybackCommand] = []++ init(_ results: [MediaPlaybackQueryResult]) { self.results = results }++ func query() async -> MediaPlaybackQueryResult {+ self.inFlight += 1+ self.maximumInFlight = max(self.maximumInFlight, self.inFlight)+ defer { self.inFlight -= 1 }+ self.queryCount += 1+ if let (count, continuation) = self.queryWaiter, self.queryCount >= count {+ self.queryWaiter = nil+ continuation.resume()+ }+ if self.queryCount == self.heldQueryIndex {+ return await withCheckedContinuation { self.queryContinuation = $0 }}+ return self.results.isEmpty ? .unavailable("exhausted") : self.results.removeFirst()}- func complete(with trackInfo: TrackInfo?, retainingCallback: Bool = false) {- let callback = self.callback- if !retainingCallback {- self.callback = nil+ func send(_ command: MediaPlaybackCommand) async -> MediaPlaybackCommandResult {+ self.inFlight += 1+ self.maximumInFlight = max(self.maximumInFlight, self.inFlight)+ defer { self.inFlight -= 1 }+ self.commands.append(command)+ if let (count, continuation) = self.commandWaiter, self.commands.count >= count {+ self.commandWaiter = nil+ continuation.resume()}- callback?(trackInfo)+ if self.commands.count == self.heldCommandIndex {+ return await withCheckedContinuation { self.commandContinuation = $0 }+ }+ return .helperCompleted}-}-@MainActor-private final class ManualTimeoutScheduler {- private struct ScheduledAction {- let deadline: TimeInterval- let action: @MainActor @Sendable () -> Void+ func holdQuery(_ index: Int) { self.heldQueryIndex = index }+ func holdCommand(_ index: Int) { self.heldCommandIndex = index }+ func releaseQuery(_ result: MediaPlaybackQueryResult) {+ self.queryContinuation?.resume(returning: result)+ self.queryContinuation = nil}- private var currentTime: TimeInterval = 0- private var scheduledActions: [ScheduledAction] = []+ func releaseCommand(_ result: MediaPlaybackCommandResult) {+ self.commandContinuation?.resume(returning: result)+ self.commandContinuation = nil+ }++ func waitForQuery(_ count: Int) async {+ guard self.queryCount < count else { return }+ await withCheckedContinuation { self.queryWaiter = (count, $0) }+ }- var scheduledDelays: [TimeInterval] {- self.scheduledActions.map(\.deadline)+ func waitForCommand(_ count: Int) async {+ guard self.commands.count < count else { return }+ await withCheckedContinuation { self.commandWaiter = (count, $0) }}+}++private final nonisolated class MediaTestClock: @unchecked Sendable {+ private let lock = NSLock()+ private var time: TimeInterval = 0- func schedule(after delay: TimeInterval, action: @escaping @MainActor @Sendable () -> Void) {- self.scheduledActions.append(- ScheduledAction(deadline: self.currentTime + delay, action: action)- )+ var value: TimeInterval {+ self.lock.lock()+ defer { self.lock.unlock() }+ return self.time}- func advance(by interval: TimeInterval) {- self.currentTime += interval- let readyActions = self.scheduledActions.filter { $0.deadline <= self.currentTime }- self.scheduledActions.removeAll { $0.deadline <= self.currentTime }- readyActions.forEach { $0.action() }+ func advance(_ seconds: TimeInterval) {+ self.lock.lock()+ self.time += seconds+ self.lock.unlock()}}-#endif