feat: mute system audio during dictation (#3)

Adds opt-in setting to silence the default output device while a
dictation session is active, so media playing in other apps cannot
bleed into the microphone and corrupt transcriptions.

Implementation:
- SystemAudioDucker (Utilities/SystemAudioDucker.swift): reads and
  writes kAudioDevicePropertyMute on the current default output device
  via CoreAudio. Saves the device's pre-session mute state and
  restores it on stop, so the user's volume is never touched. Devices
  that don't support the mute property (some Bluetooth sinks) are
  silently ignored.
- AppState: new muteSystemAudio Bool setting persisted in UserDefaults;
  duck() is called right before AVAudioRecorder starts (including
  restore in the error path) and restore() is called as soon as
  recording stops, before the transcription wait.
- HomeView: "Mute system audio while dictating" toggle added to the
  Transcription section alongside the existing punctuation toggle.

Validated: build succeeds, toggle persists across restarts, other audio
is silenced on hotkey press and restored when dictation ends.

Co-authored-by: Monawwar Abdullah <hello@monawwar.io>

Author: HarshJa1n

Wave/AppState.swift

@@ -36,6 +36,8 @@ final class AppState {
     var includePunctuation: Bool {
         didSet { UserDefaults.standard.set(includePunctuation, forKey: "includePunctuation") }
     }
+    var muteSystemAudio: Bool {
+        didSet { UserDefaults.standard.set(muteSystemAudio, forKey: "muteSystemAudio") }
     var customVocabulary: [String] {
         didSet { UserDefaults.standard.set(customVocabulary, forKey: "customVocabulary") }
     }
@@ -69,6 +71,7 @@ final class AppState {
         } else {
             includePunctuation = UserDefaults.standard.bool(forKey: "includePunctuation")
         }
+        muteSystemAudio = UserDefaults.standard.bool(forKey: "muteSystemAudio")
         customVocabulary = UserDefaults.standard.stringArray(forKey: "customVocabulary") ?? []
 
         // Default shortcut: Control + Space
@@ -134,8 +137,10 @@ final class AppState {
         do {
             status = .recording
             showOverlay()
+            if muteSystemAudio { SystemAudioDucker.duck() }
             try await transcriptionService.startRecording()
         } catch {
+            if muteSystemAudio { SystemAudioDucker.restore() }
             status = .error("Recording failed")
             hideOverlay()
             try? await Task.sleep(for: .seconds(2))
@@ -147,6 +152,8 @@ final class AppState {
         status = .transcribing
         updateOverlay()
 
+        let text = await transcriptionService.stopRecordingAndTranscribe(includePunctuation: includePunctuation)
+        if muteSystemAudio { SystemAudioDucker.restore() }
         let prompt = customVocabulary.isEmpty ? nil : customVocabulary.joined(separator: ", ")
         let text = await transcriptionService.stopRecordingAndTranscribe(includePunctuation: includePunctuation, initialPrompt: prompt)
 

Wave/Utilities/SystemAudioDucker.swift

@@ -0,0 +1,60 @@
+import CoreAudio
+
+/// Saves and restores the default output device's mute state around a dictation session.
+/// Uses CoreAudio's `kAudioDevicePropertyMute` rather than changing volume so the
+/// user's volume setting is never touched.
+enum SystemAudioDucker {
+    private static var savedMuteState: Bool = false
+
+    /// Snapshot the current mute state, then mute system output.
+    static func duck() {
+        savedMuteState = isMuted()
+        setMuted(true)
+    }
+
+    /// Restore the mute state captured at the last `duck()` call.
+    static func restore() {
+        setMuted(savedMuteState)
+    }
+
+    // MARK: - Private
+
+    private static func isMuted() -> Bool {
+        guard let device = defaultOutputDevice() else { return false }
+        var mute: UInt32 = 0
+        var size = UInt32(MemoryLayout<UInt32>.size)
+        var address = mutePropertyAddress()
+        let status = AudioObjectGetPropertyData(device, &address, 0, nil, &size, &mute)
+        return status == noErr && mute != 0
+    }
+
+    private static func setMuted(_ muted: Bool) {
+        guard let device = defaultOutputDevice() else { return }
+        var mute = UInt32(muted ? 1 : 0)
+        var address = mutePropertyAddress()
+        // Silently ignore devices that don't support the mute property (e.g. some BT sinks)
+        AudioObjectSetPropertyData(device, &address, 0, nil, UInt32(MemoryLayout<UInt32>.size), &mute)
+    }
+
+    private static func defaultOutputDevice() -> AudioDeviceID? {
+        var device = AudioDeviceID(kAudioObjectUnknown)
+        var size = UInt32(MemoryLayout<AudioDeviceID>.size)
+        var address = AudioObjectPropertyAddress(
+            mSelector: kAudioHardwarePropertyDefaultOutputDevice,
+            mScope: kAudioObjectPropertyScopeGlobal,
+            mElement: kAudioObjectPropertyElementMain
+        )
+        let status = AudioObjectGetPropertyData(
+            AudioObjectID(kAudioObjectSystemObject), &address, 0, nil, &size, &device
+        )
+        return (status == noErr && device != kAudioObjectUnknown) ? device : nil
+    }
+
+    private static func mutePropertyAddress() -> AudioObjectPropertyAddress {
+        AudioObjectPropertyAddress(
+            mSelector: kAudioDevicePropertyMute,
+            mScope: kAudioDevicePropertyScopeOutput,
+            mElement: kAudioObjectPropertyElementMain
+        )
+    }
+}

Wave/Views/HomeView.swift

@@ -52,6 +52,7 @@ struct HomeView: View {
                 Text("Transcription")
                     .font(.headline)
                 Toggle("Include punctuation", isOn: $state.includePunctuation)
+                Toggle("Mute system audio while dictating", isOn: $state.muteSystemAudio)
             }
 
             // Dictionary section