@hasna/recordings 0.3.13 → 0.5.0

package/src/native/Recordings/App/RecordingsStore.swift

@@ -1,136 +1,152 @@
 import Foundation
 import SwiftUI
 import Combine
+import AVFoundation
 import RecordingsLib
 
-/// Which main pane the canvas shows.
-enum Pane: Equatable {
-    case record       // the recording workspace (default / first screen)
-    case library      // browse past recordings
-}
-
-/// Sidebar filter selection for the library.
-enum LibraryFilter: Hashable {
-    case all
-    case project(String)     // project id
-    case noProject
-    case mode(String)        // "raw" | "enhanced"
-    case thisMachine
-    case machine(String)
-}
-
 /// Observable application state for the full macOS app. Bridges the live `RecordingEngine`,
-/// the `ProjectStore` / `VoiceShortcuts`, and the `recordings` CLI Store.
+/// global cleanup preferences, voice shortcuts, and the `recordings` CLI Store.
 @MainActor
 final class RecordingsStore: ObservableObject {
     let engine: RecordingEngine
-    let projectStore: ProjectStore
+    let preferences: ProjectStore
     let voiceShortcuts: VoiceShortcuts
 
-    @Published var pane: Pane = .record
-    @Published var library: [Recording] = []
+    @Published var library: [Recording] = [] { didSet { updateVisibleRecordings() } }
     @Published var selection: String?
-    @Published var filter: LibraryFilter = .all
-    @Published var searchText: String = ""
+    @Published var searchText: String = "" { didSet { updateVisibleRecordings() } }
+    @Published private(set) var visibleRecordings: [Recording] = []
+    @Published var showMenuBar = UserDefaults.standard.object(forKey: "recordingsShowMenuBar") as? Bool ?? true {
+        didSet { UserDefaults.standard.set(showMenuBar, forKey: "recordingsShowMenuBar") }
+    }
     @Published var isLoadingLibrary = false
     @Published var loadError: String?
     @Published var operationError: String?
 
-    @Published var stats: RecordingStats?
-    let localMachineID: String
+    @Published private(set) var isPlaying = false
+    @Published private(set) var playbackTime: Double = 0
+    @Published private(set) var playbackProgress: Double = 0
+    @Published private(set) var playbackRecordingID: String?
+    @Published private(set) var hasPlayback = false
+    private var player: AVAudioPlayer?
+    private var playbackTimer: Timer?
+
+    func beginRecording() {
+        guard !isVisualPreview else { return }
+        clearPlayback()
+        engine.startRecording()
+    }
+
+    func prepareLatestPlayback() {
+        guard !engine.captureIsActive, let path = engine.latestAudioPath,
+              FileManager.default.fileExists(atPath: path) else { return }
+        preparePlayback(path: path, id: nil, play: false)
+    }
+
+    func canPlay(_ recording: Recording) -> Bool {
+        recording.audioPath.map { FileManager.default.fileExists(atPath: $0) } ?? false
+    }
+
+    func play(_ recording: Recording) {
+        guard !engine.captureIsActive else { return }
+        if playbackRecordingID == recording.id { toggleLatestPlayback(); return }
+        guard let path = recording.audioPath else { return }
+        preparePlayback(path: path, id: recording.id, play: true)
+    }
+
+    private func preparePlayback(path: String, id: String?, play: Bool) {
+        clearPlayback()
+        do {
+            player = try AVAudioPlayer(contentsOf: URL(fileURLWithPath: path))
+            player?.prepareToPlay()
+            hasPlayback = true
+            playbackRecordingID = id
+            playbackTime = player?.duration ?? 0
+            if play { toggleLatestPlayback() }
+        } catch { operationError = "This recording’s audio could not be opened." }
+    }
+
+    func toggleLatestPlayback() {
+        guard let player else { return }
+        if isPlaying {
+            player.pause(); isPlaying = false; playbackTimer?.invalidate(); return
+        }
+        guard player.play() else { operationError = "Audio playback could not start."; return }
+        isPlaying = true
+        playbackTimer = Timer.scheduledTimer(withTimeInterval: 0.1, repeats: true) { [weak self] _ in
+            Task { @MainActor [weak self] in
+                guard let self, let player = self.player else { return }
+                self.playbackTime = player.currentTime
+                self.playbackProgress = player.duration > 0 ? player.currentTime / player.duration : 0
+                if !player.isPlaying { self.clearPlayback() }
+            }
+        }
+    }
+
+    func clearPlayback() {
+        playbackTimer?.invalidate(); playbackTimer = nil
+        player?.stop(); player = nil
+        isPlaying = false; hasPlayback = false
+        playbackRecordingID = nil; playbackTime = 0; playbackProgress = 0
+        if !engine.captureIsActive { engine.recordingDuration = 0 }
+    }
+
+    var isVisualPreview = false
     private let home: String
     private var cancellables = Set<AnyCancellable>()
+    private var connectionRevision = 0
 
     init(engine: RecordingEngine = RecordingEngine(),
-         projectStore: ProjectStore = ProjectStore(),
+         preferences: ProjectStore = ProjectStore(),
          voiceShortcuts: VoiceShortcuts = VoiceShortcuts()) {
         self.engine = engine
-        self.projectStore = projectStore
+        self.preferences = preferences
         self.voiceShortcuts = voiceShortcuts
         self.home = FileManager.default.homeDirectoryForCurrentUser.path
-        self.localMachineID = NativeMachineIdentity.current()
-        engine.projectStore = projectStore
+        engine.projectStore = nil
+        engine.globalRecordingPreferences = preferences
         engine.voiceShortcuts = voiceShortcuts
 
         // Re-publish the wrapped ObservableObjects so views that observe only this store
-        // refresh on live recording changes (timer, live text) and project edits.
+        // refresh on live recording changes (timer, live text) and preference edits.
         engine.objectWillChange
             .sink { [weak self] in self?.objectWillChange.send() }
             .store(in: &cancellables)
         engine.$persistedRecordingRevision
             .dropFirst()
-            .sink { [weak self] _ in self?.loadLibrary() }
+            .sink { [weak self] _ in self?.loadLibrary(); self?.prepareLatestPlayback()
+                if UserDefaults.standard.bool(forKey: "recordingsNotificationSound") { NSSound(named: "Pop")?.play() } }
+            .store(in: &cancellables)
+        engine.$isRecording.dropFirst().filter { $0 }
+            .sink { [weak self] _ in self?.clearPlayback() }
             .store(in: &cancellables)
-        projectStore.objectWillChange
+        preferences.objectWillChange
             .sink { [weak self] in self?.objectWillChange.send() }
             .store(in: &cancellables)
         voiceShortcuts.objectWillChange
             .sink { [weak self] in self?.objectWillChange.send() }
             .store(in: &cancellables)
-
-        reconcileProjects()
-    }
-
-    func reconcileProjects() {
-        let home = self.home
-        Task { [weak self] in
-            guard let self else { return }
-            do {
-                try await projectStore.reconcileWithCanonicalStore(home: home)
-                self.operationError = nil
-            } catch {
-                self.operationError = projectStore.persistenceError
-                    ?? (error as? RecordingsCLI.Failure)?.message
-                    ?? error.localizedDescription
+        NotificationCenter.default.publisher(for: ServiceAPIConfiguration.didChangeNotification)
+            .receive(on: RunLoop.main)
+            .sink { [weak self] _ in
+                guard let self else { return }
+                self.connectionRevision += 1
+                self.library = []
+                self.selection = nil
+                self.loadError = nil
+                self.loadLibrary()
             }
-        }
-    }
-
-    // MARK: - Derived collections
-
-    var projects: [RecProject] { projectStore.settings.projects }
-
-    var machines: [String] {
-        Set(library.compactMap { $0.machineId }.filter { !$0.isEmpty })
-            .sorted { $0.localizedCaseInsensitiveCompare($1) == .orderedAscending }
-    }
-
-    var lastUpdated: Date? { library.compactMap(\.createdDate).max() }
-
-    var visibleRecordings: [Recording] {
-        library.filter { matchesFilter($0) && matchesSearch($0) }
-    }
-
-    private func matchesFilter(_ r: Recording) -> Bool {
-        switch filter {
-        case .all: return true
-        case .project(let id): return r.projectId == id
-        case .noProject: return r.projectId == nil
-        case .mode(let m): return r.processingMode == m
-        case .thisMachine: return r.machineId == localMachineID
-        case .machine(let m): return r.machineId == m
-        }
+            .store(in: &cancellables)
     }
 
-    private func matchesSearch(_ r: Recording) -> Bool {
+    // Recording ticks and transcript deltas must not rescan the entire history.
+    private func updateVisibleRecordings() {
         let q = searchText.trimmingCharacters(in: .whitespacesAndNewlines)
-        guard !q.isEmpty else { return true }
-        if r.displayText.localizedCaseInsensitiveContains(q) { return true }
-        if r.tags.contains(where: { $0.localizedCaseInsensitiveContains(q) }) { return true }
-        return false
-    }
-
-    func count(for filter: LibraryFilter) -> Int {
-        library.filter {
-            switch filter {
-            case .all: return true
-            case .project(let id): return $0.projectId == id
-            case .noProject: return $0.projectId == nil
-            case .mode(let m): return $0.processingMode == m
-            case .thisMachine: return $0.machineId == localMachineID
-            case .machine(let m): return $0.machineId == m
-            }
-        }.count
+        guard !q.isEmpty else { visibleRecordings = library; return }
+        visibleRecordings = library.filter { recording in
+            recording.displayText.localizedCaseInsensitiveContains(q) ||
+                recording.tags.contains { $0.localizedCaseInsensitiveContains(q) }
+        }
     }
 
     var selectedRecording: Recording? {
@@ -138,40 +154,38 @@ final class RecordingsStore: ObservableObject {
         return library.first { $0.id == id }
     }
 
-    func projectName(_ id: String?) -> String? {
-        guard let id else { return nil }
-        return projects.first { $0.id == id }?.name
-    }
-
     // MARK: - Library loading
 
     private var reloadRequestedDuringLoad = false
 
     func loadLibrary() {
+        guard !isVisualPreview else { return }
         guard !isLoadingLibrary else { reloadRequestedDuringLoad = true; return }
         isLoadingLibrary = true
         let home = home
+        let revision = connectionRevision
         Task.detached(priority: .userInitiated) {
-            let result: Result<([Recording], RecordingStats?), Error>
+            let result: Result<[Recording], Error>
             do {
                 let recs = try RecordingsCLI.listAll(home: home)
-                let stats = try? RecordingsCLI.stats(home: home)
-                result = .success((recs, stats))
+                result = .success(recs)
             } catch {
                 result = .failure(error)
             }
             await MainActor.run {
                 self.isLoadingLibrary = false
-                switch result {
-                case .success(let (recs, stats)):
-                    self.library = recs
-                    self.stats = stats
-                    self.loadError = nil
-                    if self.selection == nil || !recs.contains(where: { $0.id == self.selection }) {
-                        self.selection = self.visibleRecordings.first?.id
+                // A response from the previous endpoint must not repopulate this library.
+                if revision == self.connectionRevision {
+                    switch result {
+                    case .success(let recs):
+                        self.library = recs
+                        self.loadError = nil
+                        if let selection = self.selection, !recs.contains(where: { $0.id == selection }) {
+                            self.selection = nil
+                        }
+                    case .failure(let error):
+                        self.loadError = (error as? RecordingsCLI.Failure)?.message ?? error.localizedDescription
                     }
-                case .failure(let error):
-                    self.loadError = (error as? RecordingsCLI.Failure)?.message ?? error.localizedDescription
                 }
                 if self.reloadRequestedDuringLoad {
                     self.reloadRequestedDuringLoad = false
@@ -182,6 +196,7 @@ final class RecordingsStore: ObservableObject {
     }
 
     func delete(id: String) {
+        if isVisualPreview { library.removeAll { $0.id == id }; selection = nil; return }
         let home = home
         Task.detached(priority: .userInitiated) {
             let result: Result<Void, Error>
@@ -195,7 +210,7 @@ final class RecordingsStore: ObservableObject {
                 switch result {
                 case .success:
                     self.library.removeAll { $0.id == id }
-                    if self.selection == id { self.selection = self.visibleRecordings.first?.id }
+                    if self.selection == id { self.selection = nil }
                 case .failure(let error):
                     self.operationError = (error as? RecordingsCLI.Failure)?.message ?? error.localizedDescription
                 }

package/src/native/Recordings/App/Theme.swift

@@ -1,87 +1,99 @@
-import RecordingsLib
 import SwiftUI
+import AppKit
+import RecordingsLib
 
-/// Design tokens and Liquid Glass helpers for the Recordings app. Mirrors the Hasna Notes
-/// visual system (narrow colored Liquid-Glass sidebar + one continuous canvas, hairline
-/// dividers, rounded type) with a Recordings identity: an "infinity violet→indigo" sidebar.
 enum Theme {
-    /// Accent used for selection highlights and small affordances.
-    static let accent = Color(red: 0.42, green: 0.34, blue: 0.92)
-    static let recordRed = Color(red: 0.92, green: 0.26, blue: 0.30)
-
+    static let accent = Color.primary
+    static let recordRed = Color(red: 1, green: 0.24, blue: 0.25)
     static let cornerLarge: CGFloat = 22
     static let cornerMedium: CGFloat = 14
     static let cornerSmall: CGFloat = 9
+    static func canvas(_ scheme: ColorScheme) -> Color { Color(NSColor.windowBackgroundColor) }
+    static func clock(_ seconds: Double) -> String {
+        let total = max(0, Int(seconds))
+        return String(format: "%02d:%02d", total / 60, total % 60)
+    }
+}
 
-    /// Deliberately narrow, Apple-style sidebar.
-    static let sidebarWidth: CGFloat = 204
+/// A single native backdrop per window; controls share lightweight glass highlights.
+struct FrostedBackground: View {
+    var radius: CGFloat = 16
+    var cool = false
+    var body: some View { RecordingGlassBackground(radius: radius) }
+}
 
-    /// Continuous main canvas color: pure white in light mode, system window background in dark.
-    static func canvas(_ scheme: ColorScheme) -> Color {
-        scheme == .dark ? Color(NSColor.windowBackgroundColor) : .white
+struct GlassInset: View {
+    var radius: CGFloat = 8
+    var body: some View {
+        RoundedRectangle(cornerRadius: radius)
+            .fill(LinearGradient(colors: [.white.opacity(0.26), .white.opacity(0.06)], startPoint: .topLeading, endPoint: .bottomTrailing))
+            .overlay(RoundedRectangle(cornerRadius: radius).strokeBorder(.white.opacity(0.45), lineWidth: 0.5))
+            .shadow(color: .black.opacity(0.04), radius: 2, y: 1)
     }
+}
 
-    /// "Infinity violet" sidebar gradient rendered behind the Liquid Glass rows so the glass
-    /// refracts the color. Darkened in dark mode so white text stays legible.
-    static func sidebarGradient(_ scheme: ColorScheme) -> LinearGradient {
-        let colors: [Color] = scheme == .dark
-            ? [Color(red: 0.16, green: 0.09, blue: 0.34),
-               Color(red: 0.20, green: 0.12, blue: 0.44),
-               Color(red: 0.28, green: 0.12, blue: 0.46)]
-            : [Color(red: 0.30, green: 0.18, blue: 0.66),
-               Color(red: 0.28, green: 0.20, blue: 0.76),
-               Color(red: 0.44, green: 0.18, blue: 0.70)]
-        return LinearGradient(colors: colors, startPoint: .top, endPoint: .bottom)
+struct GlassButtonStyle: ButtonStyle {
+    func makeBody(configuration: Configuration) -> some View {
+        configuration.label.padding(6).background(GlassInset())
+            .opacity(configuration.isPressed ? 0.65 : 1)
     }
 }
 
-extension View {
-    /// Liquid Glass surface on macOS 26, honoring reduce-transparency. Used sparingly —
-    /// chiefly the sidebar rows and the record hero — never as boxed panels in the canvas.
-    @ViewBuilder
-    func glassSurface(cornerRadius: CGFloat, tint: Color? = nil, interactive: Bool = false) -> some View {
-        modifier(GlassSurface(cornerRadius: cornerRadius, tint: tint, interactive: interactive))
+struct GlassCircle: View {
+    let symbol: String
+    var size: CGFloat = 44
+    var red = false
+    var progress: Double? = nil
+    var body: some View {
+        ZStack {
+            Circle().fill(.white.opacity(0.20)).padding(-3)
+            Circle()
+                .fill(LinearGradient(colors: red
+                    ? [Color(red: 1, green: 0.38, blue: 0.38), Color(red: 0.94, green: 0.18, blue: 0.19)]
+                    : [.white.opacity(0.58), .white.opacity(0.06), .white.opacity(0.25)], startPoint: .topLeading, endPoint: .bottomTrailing))
+                .shadow(color: red ? .red.opacity(0.26) : .black.opacity(0.10), radius: red ? 22 : 9, y: 4)
+            Circle().strokeBorder(.white.opacity(red ? 0.8 : 0.95), lineWidth: 1.2)
+            Circle().strokeBorder(.black.opacity(red ? 0.05 : 0.07), lineWidth: 1).padding(-2)
+            if let progress {
+                Circle().trim(from: 0, to: min(1, max(0, progress)))
+                    .stroke(.gray.opacity(0.72), style: StrokeStyle(lineWidth: 4, lineCap: .round))
+                    .rotationEffect(.degrees(-90)).padding(-5)
+            }
+            Image(systemName: symbol)
+                .font(.system(size: size * (symbol == "mic.fill" ? 0.34 : size > 100 ? 0.34 : 0.46), weight: .regular))
+                .foregroundStyle(red ? .white : Theme.accent)
+                .shadow(color: .white.opacity(0.85), radius: 0, y: 1)
+        }
+        .frame(width: size, height: size)
     }
 }
 
-private struct GlassSurface: ViewModifier {
-    let cornerRadius: CGFloat
-    let tint: Color?
-    let interactive: Bool
-    @Environment(\.accessibilityReduceTransparency) private var reduceTransparency
-
-    @ViewBuilder
-    func body(content: Content) -> some View {
-        switch ChromeSurface.forReducedTransparency(reduceTransparency) {
-        case .opaque:
-            // Reduce Transparency: opaque system background, never a translucent material.
-            content
-                .background(
-                    Color(NSColor.windowBackgroundColor),
-                    in: RoundedRectangle(cornerRadius: cornerRadius, style: .continuous)
-                )
-                .overlay(
-                    RoundedRectangle(cornerRadius: cornerRadius, style: .continuous)
-                        .strokeBorder(.separator, lineWidth: 1)
-                )
-        case .liquidGlass:
-            content.glassEffect(makeGlass(), in: .rect(cornerRadius: cornerRadius))
-        }
+struct GlassIconButton: View {
+    let symbol: String
+    let label: String
+    var size: CGFloat = 28
+    let action: () -> Void
+    var body: some View {
+        Button(action: action) { GlassCircle(symbol: symbol, size: size) }
+            .buttonStyle(.plain).help(label).accessibilityLabel(label)
     }
+}
 
-    private func makeGlass() -> Glass {
-        var glass: Glass = .regular
-        if let tint { glass = glass.tint(tint) }
-        if interactive { glass = glass.interactive() }
-        return glass
+extension View {
+    func glassSurface(cornerRadius: CGFloat, tint: Color? = nil, interactive: Bool = false) -> some View {
+        background(FrostedBackground(radius: cornerRadius))
     }
 }
 
 extension Date {
-    /// Compact relative description for list rows, e.g. "2h ago".
     var relativeDescription: String {
-        let f = RelativeDateTimeFormatter()
-        f.unitsStyle = .abbreviated
+        let f = RelativeDateTimeFormatter(); f.unitsStyle = .abbreviated
         return f.localizedString(for: self, relativeTo: Date())
     }
+    var recordingDateLabel: String {
+        let time = formatted(date: .omitted, time: .shortened)
+        if Calendar.current.isDateInToday(self) { return "Today, \(time)" }
+        if Calendar.current.isDateInYesterday(self) { return "Yesterday, \(time)" }
+        return formatted(.dateTime.month(.abbreviated).day().year())
+    }
 }

package/src/native/Recordings/Package.swift

@@ -8,6 +8,7 @@ let package = Package(
         .macOS(.v26)
     ],
     products: [
+        .library(name: "RecordingsLib", targets: ["RecordingsLib"]),
         .executable(name: "App", targets: ["App"]),
         .library(name: "RecordingsUpdateProtocol", targets: ["RecordingsUpdateProtocol"]),
         .executable(name: "recordings-update-broker", targets: ["RecordingsUpdateBroker"]),

package/src/native/Recordings/RecordingsLib/BlockingOperation.swift

@@ -0,0 +1,29 @@
+import Dispatch
+
+/// Bridge synchronous, potentially blocking APIs without occupying a cooperative worker.
+/// The caller still owns cancellation and generation checks: submitted work drains to its
+/// existing API deadline and returns its exact result even if its awaiting task is cancelled.
+/// Operations must not depend on Swift task-local values or task cancellation state.
+enum BlockingOperation {
+    private static let queue = DispatchQueue(
+        label: "md.recordings.blocking-operations",
+        attributes: .concurrent
+    )
+    static func run<Value: Sendable>(
+        qos: DispatchQoS.QoSClass = .userInitiated,
+        _ operation: @escaping @Sendable () -> Value
+    ) async -> Value {
+        await withCheckedContinuation { continuation in
+            queue.async(qos: DispatchQoS(qosClass: qos, relativePriority: 0)) {
+                continuation.resume(returning: operation())
+            }
+        }
+    }
+
+    static func runThrowing<Value: Sendable>(
+        qos: DispatchQoS.QoSClass = .userInitiated,
+        _ operation: @escaping @Sendable () throws -> Value
+    ) async throws -> Value {
+        try await run(qos: qos) { Result(catching: operation) }.get()
+    }
+}

package/src/native/Recordings/RecordingsLib/CaptureMonitor.swift

@@ -0,0 +1,65 @@
+import Foundation
+
+/// Keeps pause and metering on the audio-delivery queue, without publishing every PCM chunk.
+final class CaptureMonitor: @unchecked Sendable {
+    private let lock = NSLock()
+    private var paused = false
+    private var bytes = 0
+    private var level: Double = 0
+
+    func setPaused(_ value: Bool) { lock.withLock { paused = value; if value { level = 0 } } }
+
+    func admit(_ data: Data) -> Bool {
+        lock.withLock {
+            guard !paused else { return false }
+            bytes += data.count
+            var sum: Double = 0
+            var count = 0
+            data.withUnsafeBytes { raw in
+                for offset in stride(from: 0, to: max(0, raw.count - 1), by: 2) {
+                    let value = Double(Int16(bitPattern: UInt16(raw[offset]) | UInt16(raw[offset + 1]) << 8)) / 32768
+                    sum += value * value
+                    count += 1
+                }
+            }
+            level = count > 0 ? min(1, sqrt(sum / Double(count)) * 5) : 0
+            return true
+        }
+    }
+
+    func snapshot() -> (duration: Double, level: Double) {
+        lock.withLock { (Double(bytes) / 48_000, level) }
+    }
+}
+
+public enum RecentPasteDeliveryStatus: String, Codable, Sendable {
+    case confirmed
+    case unconfirmed
+    case notDelivered
+}
+
+public struct RecentPaste: Identifiable, Sendable {
+    public let id = UUID()
+    public let text: String
+    public let bundleIdentifier: String?
+    public let appName: String
+    public let location: String
+    public let timestamp = Date()
+    public let status: String
+    public let verified: Bool
+    public let captureID: String?
+    public let deliveryStatus: RecentPasteDeliveryStatus
+
+    public init(text: String, bundleIdentifier: String?, appName: String, location: String,
+                status: String, verified: Bool, captureID: String? = nil,
+                deliveryStatus: RecentPasteDeliveryStatus? = nil) {
+        self.text = text
+        self.bundleIdentifier = bundleIdentifier
+        self.appName = appName
+        self.location = location
+        self.status = status
+        self.verified = verified
+        self.captureID = captureID
+        self.deliveryStatus = deliveryStatus ?? (verified ? .confirmed : .unconfirmed)
+    }
+}

package/src/native/Recordings/RecordingsLib/Info.plist

@@ -9,7 +9,7 @@
     <key>NSSupportsAutomaticGraphicsSwitching</key>
     <true/>
     <key>CFBundleName</key>
-    <string>Recordings</string>
+    <string>Hasna Recordings</string>
     <key>CFBundleDisplayName</key>
     <string>Hasna Recordings</string>
     <key>CFBundleExecutable</key>
@@ -17,11 +17,11 @@
     <key>CFBundleIdentifier</key>
     <string>com.hasna.recordings</string>
     <key>CFBundleVersion</key>
-    <string>0.3.13</string>
+    <string>0.5.0</string>
     <key>CFBundlePackageType</key>
     <string>APPL</string>
     <key>CFBundleShortVersionString</key>
-    <string>0.3.13</string>
+    <string>0.5.0</string>
     <key>LSMinimumSystemVersion</key>
     <string>26.0</string>
     <key>NSMicrophoneUsageDescription</key>