@hasna/recordings 0.2.10 → 0.2.13

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

@@ -0,0 +1,212 @@
+import SwiftUI
+import RecordingsLib
+
+/// Narrow violet sidebar: Record · Library · Projects · Modes · Machines. White text/tint
+/// over the gradient; selected rows get a translucent white highlight (Liquid Glass refracts
+/// the violet beneath).
+struct SidebarView: View {
+    @ObservedObject var store: RecordingsStore
+    @Environment(\.colorScheme) private var colorScheme
+
+    @State private var addingProject = false
+    @State private var newProjectName = ""
+
+    var body: some View {
+        ScrollView {
+            VStack(alignment: .leading, spacing: 18) {
+                workspaceSection
+                librarySection
+                projectsSection
+                if hasAnyMode { modesSection }
+                if !store.machines.isEmpty { machinesSection }
+                Spacer(minLength: 8)
+            }
+            .padding(14)
+            .padding(.top, 24)
+        }
+        .scrollContentBackground(.hidden)
+        .foregroundStyle(.white)
+        .tint(.white)
+    }
+
+    // MARK: - Workspace
+
+    private var workspaceSection: some View {
+        section(title: "Workspace") {
+            Button {
+                withAnimation(.spring(response: 0.3, dampingFraction: 0.85)) { store.pane = .record }
+            } label: {
+                rowLabel(icon: "mic.fill", label: "Record", count: nil,
+                         selected: store.pane == .record, accentDot: store.engine.isRecording)
+            }
+            .buttonStyle(.plain)
+        }
+    }
+
+    // MARK: - Library
+
+    private var librarySection: some View {
+        section(title: "Library") {
+            filterRow(.all, icon: "waveform", label: "All Recordings")
+            if store.count(for: .noProject) > 0 {
+                filterRow(.noProject, icon: "tray", label: "No Project")
+            }
+        }
+    }
+
+    // MARK: - Projects
+
+    private var projectsSection: some View {
+        section(title: "Projects", trailing: {
+            Button { addingProject = true; newProjectName = "" } label: {
+                Image(systemName: "plus").font(.system(size: 11, weight: .semibold))
+            }
+            .buttonStyle(.plain)
+            .disabled(!store.projectStore.canMutateProjects)
+            .help("Add Project")
+            .popover(isPresented: $addingProject, arrowEdge: .trailing) {
+                VStack(alignment: .leading, spacing: 10) {
+                    Text("New Project").font(.headline)
+                    TextField("Project name", text: $newProjectName)
+                        .textFieldStyle(.roundedBorder).frame(width: 200)
+                        .onSubmit(commitNewProject)
+                    HStack {
+                        Spacer()
+                        Button("Cancel") { addingProject = false }
+                        Button("Add") { commitNewProject() }
+                            .keyboardShortcut(.defaultAction)
+                            .disabled(newProjectName.trimmingCharacters(in: .whitespaces).isEmpty)
+                    }
+                }
+                .padding(14)
+            }
+        }) {
+            if store.projects.isEmpty {
+                Text("No projects")
+                    .font(.caption).foregroundStyle(.white.opacity(0.5)).padding(.leading, 6)
+            }
+            ForEach(store.projects) { project in
+                filterRow(.project(project.id), icon: "folder", label: project.name)
+                    .disabled(!store.projectStore.canMutateProjects)
+                    .contextMenu {
+                        Button("Delete", role: .destructive) {
+                            do {
+                                try store.projectStore.removeProject(id: project.id)
+                            } catch {
+                                store.operationError = store.projectStore.persistenceError ?? error.localizedDescription
+                            }
+                        }
+                    }
+            }
+        }
+    }
+
+    private func commitNewProject() {
+        let name = newProjectName.trimmingCharacters(in: .whitespacesAndNewlines)
+        guard !name.isEmpty else { return }
+        Task {
+            do {
+                try await store.projectStore.addProject(name: name)
+                addingProject = false
+                newProjectName = ""
+            } catch {
+                store.operationError = store.projectStore.persistenceError
+                    ?? (error as? RecordingsCLI.Failure)?.message
+                    ?? error.localizedDescription
+            }
+        }
+    }
+
+    // MARK: - Modes
+
+    private var hasAnyMode: Bool {
+        store.count(for: .mode("enhanced")) > 0 || store.count(for: .mode("raw")) > 0
+    }
+
+    private var modesSection: some View {
+        section(title: "Modes") {
+            if store.count(for: .mode("enhanced")) > 0 {
+                filterRow(.mode("enhanced"), icon: "wand.and.stars", label: "Enhanced")
+            }
+            if store.count(for: .mode("raw")) > 0 {
+                filterRow(.mode("raw"), icon: "text.quote", label: "Raw")
+            }
+        }
+    }
+
+    // MARK: - Machines
+
+    private var machinesSection: some View {
+        section(title: "Machines") {
+            if store.count(for: .thisMachine) > 0 {
+                filterRow(.thisMachine, icon: "desktopcomputer", label: "This Mac")
+            }
+            ForEach(otherMachines, id: \.self) { machine in
+                filterRow(.machine(machine), icon: "macpro.gen3.server", label: machine)
+            }
+        }
+    }
+
+    private var otherMachines: [String] {
+        store.machines.filter { $0 != store.localMachineID }
+    }
+
+    // MARK: - Building blocks
+
+    @ViewBuilder
+    private func section<Trailing: View, Content: View>(
+        title: String,
+        @ViewBuilder trailing: () -> Trailing = { EmptyView() },
+        @ViewBuilder content: () -> Content
+    ) -> some View {
+        VStack(alignment: .leading, spacing: 6) {
+            HStack {
+                Text(title.uppercased())
+                    .font(.caption2.weight(.semibold))
+                    .foregroundStyle(.white.opacity(0.6))
+                    .padding(.leading, 6)
+                Spacer()
+                trailing().foregroundStyle(.white.opacity(0.85)).padding(.trailing, 6)
+            }
+            content()
+        }
+    }
+
+    private func filterRow(_ target: LibraryFilter, icon: String, label: String) -> some View {
+        let selected = store.pane == .library && store.filter == target
+        let count = store.count(for: target)
+        return Button {
+            withAnimation(.spring(response: 0.32, dampingFraction: 0.82)) {
+                store.filter = target
+                store.pane = .library
+                if !store.visibleRecordings.contains(where: { $0.id == store.selection }) {
+                    store.selection = store.visibleRecordings.first?.id
+                }
+            }
+        } label: {
+            rowLabel(icon: icon, label: label, count: count > 0 ? count : nil, selected: selected, accentDot: false)
+        }
+        .buttonStyle(.plain)
+    }
+
+    private func rowLabel(icon: String, label: String, count: Int?, selected: Bool, accentDot: Bool) -> some View {
+        HStack(spacing: 9) {
+            Image(systemName: icon).font(.system(size: 12, weight: .medium)).frame(width: 16)
+            Text(label).font(.system(.subheadline, design: .rounded)).lineLimit(1)
+            Spacer(minLength: 4)
+            if accentDot {
+                Circle().fill(Theme.recordRed).frame(width: 7, height: 7)
+            } else if let count {
+                Text("\(count)").font(.caption2.monospacedDigit()).foregroundStyle(.white.opacity(0.55))
+            }
+        }
+        .foregroundStyle(.white.opacity(selected ? 1 : 0.85))
+        .padding(.horizontal, 9).padding(.vertical, 7)
+        .contentShape(Rectangle())
+        .background {
+            if selected {
+                RoundedRectangle(cornerRadius: Theme.cornerSmall, style: .continuous).fill(.white.opacity(0.22))
+            }
+        }
+    }
+}

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

@@ -0,0 +1,87 @@
+import RecordingsLib
+import SwiftUI
+
+/// 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 cornerLarge: CGFloat = 22
+    static let cornerMedium: CGFloat = 14
+    static let cornerSmall: CGFloat = 9
+
+    /// Deliberately narrow, Apple-style sidebar.
+    static let sidebarWidth: CGFloat = 204
+
+    /// 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
+    }
+
+    /// "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)
+    }
+}
+
+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))
+    }
+}
+
+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))
+        }
+    }
+
+    private func makeGlass() -> Glass {
+        var glass: Glass = .regular
+        if let tint { glass = glass.tint(tint) }
+        if interactive { glass = glass.interactive() }
+        return glass
+    }
+}
+
+extension Date {
+    /// Compact relative description for list rows, e.g. "2h ago".
+    var relativeDescription: String {
+        let f = RelativeDateTimeFormatter()
+        f.unitsStyle = .abbreviated
+        return f.localizedString(for: self, relativeTo: Date())
+    }
+}

package/src/native/Recordings/Package.resolved

@@ -1,5 +1,5 @@
 {
-  "originHash" : "a63dc0aa4ab0839e19cd7644cfd2bb42729aafbf9ef920adeb5c3ac856b7701e",
+  "originHash" : "687b5e4737064bbc8cae591b1e3177f27923cff756de7a7c0dd0b5bfb13ab55a",
   "pins" : [
     {
       "identity" : "keyboardshortcuts",
@@ -15,8 +15,8 @@
       "kind" : "remoteSourceControl",
       "location" : "https://github.com/swiftlang/swift-syntax.git",
       "state" : {
-        "revision" : "0687f71944021d616d34d922343dcef086855920",
-        "version" : "600.0.1"
+        "revision" : "4799286537280063c85a32f09884cfbca301b1a1",
+        "version" : "602.0.0"
       }
     },
     {
@@ -24,8 +24,8 @@
       "kind" : "remoteSourceControl",
       "location" : "https://github.com/apple/swift-testing.git",
       "state" : {
-        "revision" : "399f76dcd91e4c688ca2301fa24a8cc6d9927211",
-        "version" : "0.99.0"
+        "branch" : "swift-6.2-RELEASE",
+        "revision" : "3fdabe5392108d874abae1c1e58e1328ab46f681"
       }
     }
   ],

package/src/native/Recordings/Package.swift

@@ -7,16 +7,31 @@ let package = Package(
     platforms: [
         .macOS(.v26)
     ],
+    products: [
+        .executable(name: "App", targets: ["App"]),
+        .library(name: "RecordingsUpdateProtocol", targets: ["RecordingsUpdateProtocol"]),
+        .executable(name: "recordings-update-broker", targets: ["RecordingsUpdateBroker"]),
+        .executable(name: "recordings-update-client", targets: ["RecordingsUpdateClient"]),
+        .executable(name: "recordings-envelope-signer", targets: ["RecordingsEnvelopeSigner"]),
+        .executable(
+            name: "recordings-bootstrap-preflight",
+            targets: ["RecordingsBootstrapPreflight"]
+        ),
+    ],
     dependencies: [
         .package(url: "https://github.com/sindresorhus/KeyboardShortcuts", exact: "1.12.0"),
-        .package(url: "https://github.com/apple/swift-testing.git", .upToNextMinor(from: "0.99.0")),
+        // Swift Testing pinned to the toolchain-matched release. The stations build with
+        // CommandLineTools (no bundled Testing module), so the package is required — but it
+        // must track the compiler: the archived 0.99 shim under the 6.2 compiler silently
+        // corrupted `#expect` Bool-comparison evaluation, passing false assertions.
+        .package(url: "https://github.com/apple/swift-testing.git", revision: "swift-6.2-RELEASE"),
     ],
     targets: [
         .target(
             name: "RecordingsLib",
             dependencies: ["KeyboardShortcuts"],
             path: "RecordingsLib",
-            exclude: ["Info.plist", "Recordings.entitlements"],
+            exclude: ["Info.plist", "Recordings.entitlements", "RecordingsCLI.entitlements"],
             resources: [.process("Resources")]
         ),
         .executableTarget(
@@ -24,10 +39,55 @@ let package = Package(
             dependencies: ["RecordingsLib"],
             path: "App"
         ),
+        .target(
+            name: "RecordingsUpdateProtocol",
+            path: "Updater/Protocol"
+        ),
+        .executableTarget(
+            name: "RecordingsUpdateBroker",
+            dependencies: ["RecordingsUpdateProtocol", "RecordingsVerifierLauncher"],
+            path: "Updater/Broker"
+        ),
+        .target(
+            name: "RecordingsVerifierLauncher",
+            path: "Updater/VerifierLauncher",
+            publicHeadersPath: "include"
+        ),
+        .executableTarget(
+            name: "RecordingsUpdateClient",
+            dependencies: ["RecordingsUpdateProtocol"],
+            path: "Updater/Client"
+        ),
+        .executableTarget(
+            name: "RecordingsEnvelopeSigner",
+            dependencies: ["RecordingsUpdateProtocol"],
+            path: "Updater/Signer"
+        ),
+        .executableTarget(
+            name: "RecordingsBootstrapPreflight",
+            dependencies: ["RecordingsUpdateProtocol"],
+            path: "Updater/BootstrapPreflight"
+        ),
         .testTarget(
             name: "RecordingsTests",
             dependencies: ["RecordingsLib", .product(name: "Testing", package: "swift-testing")],
             path: "RecordingsTests"
         ),
+        .testTarget(
+            name: "RecordingsUpdateProtocolTests",
+            dependencies: [
+                "RecordingsUpdateProtocol",
+                .product(name: "Testing", package: "swift-testing"),
+            ],
+            path: "Updater/ProtocolTests"
+        ),
+        .testTarget(
+            name: "RecordingsUpdateBrokerTests",
+            dependencies: [
+                "RecordingsUpdateBroker",
+                .product(name: "Testing", package: "swift-testing"),
+            ],
+            path: "Updater/BrokerTests"
+        ),
     ]
 )

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

@@ -0,0 +1,104 @@
+import Foundation
+@preconcurrency import ApplicationServices
+
+public struct AccessibilityTrustResult: Sendable, Equatable {
+    public let trusted: Bool
+    public let didPrompt: Bool
+}
+
+/// Limits automatic Accessibility prompting to one attempt for the lifetime of a process.
+/// Explicit user actions may request again, while ordinary trust checks never prompt.
+public final class AccessibilityPromptGate: @unchecked Sendable {
+    public static let processShared = AccessibilityPromptGate()
+
+    private let lock = NSLock()
+    private var automaticPromptAttempted = false
+    private var promptRequests = 0
+
+    public init() {}
+
+    public var promptRequestCount: Int {
+        lock.withLock { promptRequests }
+    }
+
+    public func trustForProtectedOperation() -> AccessibilityTrustResult {
+        trustForProtectedOperation(
+            isTrusted: { AXIsProcessTrusted() },
+            requestPrompt: { AccessibilityPromptGate.requestSystemPrompt() }
+        )
+    }
+
+    public func trustForProtectedOperation(
+        isTrusted: () -> Bool,
+        requestPrompt: () -> Bool
+    ) -> AccessibilityTrustResult {
+        if isTrusted() {
+            return AccessibilityTrustResult(trusted: true, didPrompt: false)
+        }
+
+        let shouldPrompt = lock.withLock {
+            guard !automaticPromptAttempted else { return false }
+            automaticPromptAttempted = true
+            promptRequests += 1
+            return true
+        }
+        guard shouldPrompt else {
+            return AccessibilityTrustResult(trusted: false, didPrompt: false)
+        }
+        return AccessibilityTrustResult(trusted: requestPrompt(), didPrompt: true)
+    }
+
+    public func requestExplicitly() -> AccessibilityTrustResult {
+        requestExplicitly(
+            isTrusted: { AXIsProcessTrusted() },
+            requestPrompt: { AccessibilityPromptGate.requestSystemPrompt() }
+        )
+    }
+
+    public func requestExplicitly(_ requestPrompt: () -> Bool) -> AccessibilityTrustResult {
+        requestExplicitly(isTrusted: { AXIsProcessTrusted() }, requestPrompt: requestPrompt)
+    }
+
+    public func requestExplicitly(
+        isTrusted: () -> Bool,
+        requestPrompt: () -> Bool
+    ) -> AccessibilityTrustResult {
+        lock.withLock {
+            automaticPromptAttempted = true
+            promptRequests += 1
+        }
+        _ = requestPrompt()
+        return AccessibilityTrustResult(trusted: isTrusted(), didPrompt: true)
+    }
+
+    public func recheckExplicitRequest(
+        _ promptResult: AccessibilityTrustResult,
+        isTrusted: () -> Bool
+    ) -> AccessibilityTrustResult {
+        AccessibilityTrustResult(trusted: isTrusted(), didPrompt: promptResult.didPrompt)
+    }
+
+    public func waitForExplicitRequestCompletion(
+        _ promptResult: AccessibilityTrustResult,
+        attempts: Int = 20,
+        waitBetweenAttempts: () -> Void = { Thread.sleep(forTimeInterval: 0.25) },
+        isTrusted: () -> Bool = { AXIsProcessTrusted() }
+    ) -> AccessibilityTrustResult {
+        let boundedAttempts = max(attempts, 1)
+        for attempt in 0..<boundedAttempts {
+            if isTrusted() {
+                return AccessibilityTrustResult(trusted: true, didPrompt: promptResult.didPrompt)
+            }
+            if attempt + 1 < boundedAttempts {
+                waitBetweenAttempts()
+            }
+        }
+        return AccessibilityTrustResult(trusted: false, didPrompt: promptResult.didPrompt)
+    }
+
+    private static func requestSystemPrompt() -> Bool {
+        AXIsProcessTrustedWithOptions(
+            [kAXTrustedCheckOptionPrompt.takeUnretainedValue(): true] as CFDictionary
+        )
+    }
+}

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

@@ -16,35 +16,3 @@ public struct HasnaLogoMark: View {
             .clipShape(RoundedRectangle(cornerRadius: 4, style: .continuous))
     }
 }
-
-public struct HasnaMenuBarIcon: View {
-    private let isRecording: Bool
-    private let isTranscribing: Bool
-
-    public init(isRecording: Bool, isTranscribing: Bool) {
-        self.isRecording = isRecording
-        self.isTranscribing = isTranscribing
-    }
-
-    public var body: some View {
-        ZStack(alignment: .bottomTrailing) {
-            Image("HasnaLogo", bundle: .module)
-                .resizable()
-                .renderingMode(.template)
-                .interpolation(.high)
-                .scaledToFit()
-                .frame(width: 18, height: 18)
-
-            if isRecording {
-                Circle()
-                    .fill(.red)
-                    .frame(width: 6, height: 6)
-            } else if isTranscribing {
-                Circle()
-                    .fill(.tint)
-                    .frame(width: 6, height: 6)
-            }
-        }
-        .frame(width: 22, height: 18)
-    }
-}

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

@@ -0,0 +1,17 @@
+import Foundation
+
+/// Deterministic surface contract for glass-capable chrome (the record hero, glass panels).
+/// When the user enables Reduce Transparency, chrome must render on an opaque, fully
+/// readable surface — never a translucent material, which still composites content from
+/// behind the window. Views resolve their surface through this single function so the
+/// accessibility behavior is a testable state contract rather than per-view convention.
+public enum ChromeSurface: Equatable, Sendable {
+    /// Liquid Glass — only while transparency effects are allowed.
+    case liquidGlass
+    /// Opaque window-background surface with a hairline border, honoring Reduce Transparency.
+    case opaque
+
+    public static func forReducedTransparency(_ reduceTransparency: Bool) -> ChromeSurface {
+        reduceTransparency ? .opaque : .liquidGlass
+    }
+}

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

@@ -2,7 +2,11 @@
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
 <plist version="1.0">
 <dict>
-    <key>LSUIElement</key>
+    <key>NSPrincipalClass</key>
+    <string>NSApplication</string>
+    <key>NSHighResolutionCapable</key>
+    <true/>
+    <key>NSSupportsAutomaticGraphicsSwitching</key>
     <true/>
     <key>CFBundleName</key>
     <string>Recordings</string>
@@ -13,11 +17,11 @@
     <key>CFBundleIdentifier</key>
     <string>com.hasna.recordings</string>
     <key>CFBundleVersion</key>
-    <string>1</string>
+    <string>0.2.13</string>
     <key>CFBundlePackageType</key>
     <string>APPL</string>
     <key>CFBundleShortVersionString</key>
-    <string>0.1.0</string>
+    <string>0.2.13</string>
     <key>LSMinimumSystemVersion</key>
     <string>26.0</string>
     <key>NSMicrophoneUsageDescription</key>

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

@@ -0,0 +1,37 @@
+import Foundation
+
+/// State contract for the menu-bar surface. The visual vocabulary is deliberately tiny and
+/// unchanged (mic / waveform / ellipsis, one status line, one primary button); what this
+/// type guarantees is truthfulness: whenever the engine would reject `startRecording` —
+/// including while an intent decision, answer, or rewrite is pending — the menu bar must
+/// present a busy state and a disabled Start affordance, never an idle state it would
+/// then refuse.
+public struct MenuBarPresentation: Equatable, Sendable {
+    public let iconName: String
+    public let accessibilityLabel: String
+    public let statusText: String
+    /// Whether the primary button is available. While recording the same button is the
+    /// (always enabled) Stop affordance; otherwise it is Start and must match
+    /// `RecordingEngine.canStartRecording` exactly.
+    public let primaryActionEnabled: Bool
+
+    public init(isRecording: Bool, canStartRecording: Bool, statusMessage: String) {
+        if isRecording {
+            iconName = "waveform"
+            accessibilityLabel = "Recordings, recording"
+            statusText = "Recording"
+            primaryActionEnabled = true
+        } else if !canStartRecording {
+            let normalizedBusyStatus = statusMessage.trimmingCharacters(in: .punctuationCharacters)
+            iconName = "ellipsis.circle"
+            accessibilityLabel = "Recordings, \(normalizedBusyStatus.lowercased())"
+            statusText = normalizedBusyStatus
+            primaryActionEnabled = false
+        } else {
+            iconName = "mic.fill"
+            accessibilityLabel = "Recordings"
+            statusText = statusMessage
+            primaryActionEnabled = true
+        }
+    }
+}