From d5a705d29ded57d1d3206ac5d06ab1f5305efd7f Mon Sep 17 00:00:00 2001
From: Brendan Allan <brendonovich@outlook.com>
Date: Fri, 22 Aug 2025 02:41:59 +0800
Subject: [PATCH 1/7] audio actor?

---
 Cargo.lock                                    |  11 +
 apps/desktop/src-tauri/Cargo.toml             |   1 +
 apps/desktop/src-tauri/src/lib.rs             | 132 ++++++----
 apps/desktop/src-tauri/src/recording.rs       |   6 +-
 .../src/routes/(window-chrome)/(main).tsx     |   1 +
 crates/cpal-ffmpeg/Cargo.toml                 |  11 +
 crates/cpal-ffmpeg/src/lib.rs                 |  81 +++++++
 crates/media/Cargo.toml                       |   1 +
 crates/media/src/feeds/microphone.rs          | 225 ++++++++++++++++++
 crates/media/src/feeds/mod.rs                 |   1 +
 crates/media/src/sources/audio_input.rs       |   5 +-
 crates/recording/Cargo.toml                   |   1 +
 crates/recording/src/lib.rs                   |  10 +-
 13 files changed, 428 insertions(+), 58 deletions(-)
 create mode 100644 crates/cpal-ffmpeg/Cargo.toml
 create mode 100644 crates/cpal-ffmpeg/src/lib.rs
 create mode 100644 crates/media/src/feeds/microphone.rs

diff --git a/Cargo.lock b/Cargo.lock
index 71b460c926..33c2b0309d 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -947,6 +947,14 @@ dependencies = [
  "windows-core 0.60.1",
 ]
 
+[[package]]
+name = "cap-cpal-ffmpeg"
+version = "0.1.0"
+dependencies = [
+ "cpal 0.15.3 (git+https://github.com/RustAudio/cpal?rev=f43d36e55494993bbbde3299af0c53e5cdf4d4cf)",
+ "ffmpeg-next",
+]
+
 [[package]]
 name = "cap-cursor-capture"
 version = "0.1.0"
@@ -1006,6 +1014,7 @@ dependencies = [
  "futures-intrusive",
  "global-hotkey",
  "image 0.25.6",
+ "kameo",
  "keyed_priority_queue",
  "lazy_static",
  "log",
@@ -1156,6 +1165,7 @@ dependencies = [
  "cap-camera",
  "cap-camera-ffmpeg",
  "cap-camera-windows",
+ "cap-cpal-ffmpeg",
  "cap-fail",
  "cap-flags",
  "cap-media-encoders",
@@ -1258,6 +1268,7 @@ dependencies = [
  "futures",
  "hex",
  "image 0.25.6",
+ "kameo",
  "objc",
  "objc2-app-kit",
  "relative-path",
diff --git a/apps/desktop/src-tauri/Cargo.toml b/apps/desktop/src-tauri/Cargo.toml
index af38d91fb8..ccfc75f2ff 100644
--- a/apps/desktop/src-tauri/Cargo.toml
+++ b/apps/desktop/src-tauri/Cargo.toml
@@ -101,6 +101,7 @@ md5 = "0.7.0"
 tokio-util = "0.7.15"
 wgpu.workspace = true
 bytemuck = "1.23.1"
+kameo = "0.17.2"
 
 [target.'cfg(target_os = "macos")'.dependencies]
 core-graphics = "0.24.0"
diff --git a/apps/desktop/src-tauri/src/lib.rs b/apps/desktop/src-tauri/src/lib.rs
index 46dca64d57..15021515ad 100644
--- a/apps/desktop/src-tauri/src/lib.rs
+++ b/apps/desktop/src-tauri/src/lib.rs
@@ -25,50 +25,49 @@ mod windows;
 use audio::AppSounds;
 use auth::{AuthStore, AuthenticationInvalid, Plan};
 use camera::{CameraPreview, CameraWindowState};
-use cap_editor::EditorInstance;
-use cap_editor::EditorState;
-use cap_media::feeds::RawCameraFrame;
-use cap_media::feeds::{AudioInputFeed, AudioInputSamplesSender};
-use cap_media::platform::Bounds;
-use cap_media::{feeds::CameraFeed, sources::ScreenCaptureTarget};
-use cap_project::RecordingMetaInner;
-use cap_project::XY;
+use cap_editor::{EditorInstance, EditorState};
+use cap_media::{
+    feeds::{
+        self, AudioInputFeed, AudioInputSamplesSender, CameraFeed, RawCameraFrame,
+        microphone::MicrophoneFeed,
+    },
+    platform::Bounds,
+    sources::ScreenCaptureTarget,
+};
 use cap_project::{
-    ProjectConfiguration, RecordingMeta, SharingMeta, StudioRecordingMeta, ZoomSegment,
+    ProjectConfiguration, RecordingMeta, RecordingMetaInner, SharingMeta, StudioRecordingMeta, XY,
+    ZoomSegment,
 };
 use cap_rendering::ProjectRecordingsMeta;
-use clipboard_rs::common::RustImage;
-use clipboard_rs::{Clipboard, ClipboardContext};
-use editor_window::EditorInstances;
-use editor_window::WindowEditorInstance;
+use clipboard_rs::{Clipboard, ClipboardContext, common::RustImage};
+use editor_window::{EditorInstances, WindowEditorInstance};
 use general_settings::GeneralSettingsStore;
+use kameo::{Actor, actor::ActorRef};
 use mp4::Mp4Reader;
 use notifications::NotificationType;
 use png::{ColorType, Encoder};
 use recording::InProgressRecording;
 use relative_path::RelativePathBuf;
-
-use scap::capturer::Capturer;
-use scap::frame::Frame;
-use scap::frame::VideoFrame;
+use scap::{
+    capturer::Capturer,
+    frame::{Frame, VideoFrame},
+};
 use serde::{Deserialize, Serialize};
 use serde_json::json;
 use specta::Type;
-use std::collections::BTreeMap;
-use std::path::Path;
-use std::time::Duration;
 use std::{
+    collections::BTreeMap,
     fs::File,
     future::Future,
     io::{BufReader, BufWriter},
     marker::PhantomData,
-    path::PathBuf,
+    path::{Path, PathBuf},
     process::Command,
     str::FromStr,
     sync::Arc,
+    time::Duration,
 };
-use tauri::Window;
-use tauri::{AppHandle, Manager, State, WindowEvent};
+use tauri::{AppHandle, Manager, State, Window, WindowEvent};
 use tauri_plugin_deep_link::DeepLinkExt;
 use tauri_plugin_dialog::DialogExt;
 use tauri_plugin_global_shortcut::GlobalShortcutExt;
@@ -76,17 +75,14 @@ use tauri_plugin_notification::{NotificationExt, PermissionState};
 use tauri_plugin_opener::OpenerExt;
 use tauri_plugin_shell::ShellExt;
 use tauri_specta::Event;
-use tokio::sync::mpsc;
-use tokio::sync::{Mutex, RwLock};
-use tokio::time::timeout;
-use tracing::debug;
-use tracing::error;
-use tracing::trace;
+use tokio::{
+    sync::{Mutex, RwLock, mpsc},
+    time::timeout,
+};
+use tracing::{debug, error, trace};
 use upload::{S3UploadMeta, create_or_get_video, upload_image, upload_video};
 use web_api::ManagerExt as WebManagerExt;
-use windows::EditorWindowIds;
-use windows::set_window_transparent;
-use windows::{CapWindowId, ShowCapWindow};
+use windows::{CapWindowId, EditorWindowIds, ShowCapWindow, set_window_transparent};
 
 #[allow(clippy::large_enum_variant)]
 pub enum RecordingState {
@@ -107,8 +103,8 @@ pub struct App {
     camera_feed: Option<Arc<Mutex<CameraFeed>>>,
     #[serde(skip)]
     camera_feed_initialization: Option<mpsc::Sender<()>>,
-    #[serde(skip)]
-    mic_feed: Option<AudioInputFeed>,
+    // #[serde(skip)]
+    // mic_feed: Option<AudioInputFeed>,
     #[serde(skip)]
     mic_samples_tx: AudioInputSamplesSender,
     #[serde(skip)]
@@ -117,6 +113,8 @@ pub struct App {
     recording_state: RecordingState,
     #[serde(skip)]
     recording_logging_handle: LoggingHandle,
+    #[serde(skip)]
+    mic_feed_actor: Option<ActorRef<feeds::microphone::MicrophoneFeed>>,
     server_url: String,
 }
 
@@ -221,25 +219,58 @@ impl App {
 async fn set_mic_input(state: MutableState<'_, App>, label: Option<String>) -> Result<(), String> {
     let mut app = state.write().await;
 
-    match (label, &mut app.mic_feed) {
-        (Some(label), None) => {
-            AudioInputFeed::init(&label)
-                .await
-                .map_err(|e| e.to_string())
-                .map(async |feed| {
-                    feed.add_sender(app.mic_samples_tx.clone()).await.unwrap();
-                    app.mic_feed = Some(feed);
-                })
-                .transpose_async()
-                .await
+    match label {
+        None => {
+            app.mic_feed_actor.take();
         }
-        (Some(label), Some(feed)) => feed.switch_input(&label).await.map_err(|e| e.to_string()),
-        (None, _) => {
-            debug!("removing mic in set_start_recording_options");
-            app.mic_feed.take();
-            Ok(())
+        Some(label) => {
+            let mic_feed_actor = app.mic_feed_actor.get_or_insert_with(|| {
+                let (error_tx, error_rx) = flume::bounded(1);
+
+                // TODO: make this part of a global actor one day
+                tokio::spawn(async move {
+                    let Ok(err) = error_rx.recv_async().await else {
+                        return;
+                    };
+
+                    error!("Mic feed actor error: {err}");
+                });
+
+                MicrophoneFeed::spawn(MicrophoneFeed::new(error_tx))
+            });
+
+            let _ = mic_feed_actor
+                .ask(feeds::microphone::AddSender(app.mic_samples_tx.clone()))
+                .await;
+
+            drop(app);
+
+            let _config = mic_feed_actor
+                .ask(feeds::microphone::SetInput { label })
+                .await
+                .map_err(|e| e.to_string())?;
         }
     }
+
+    // match (label, &mut app.mic_feed) {
+    //     (Some(label), None) => {
+    //         AudioInputFeed::init(&label)
+    //             .await
+    //             .map_err(|e| e.to_string())
+    //             .map(async |feed| {
+    //                 feed.add_sender(app.mic_samples_tx.clone()).await.unwrap();
+    //                 app.mic_feed = Some(feed);
+    //             })
+    //             .transpose_async()
+    //             .await
+    //     }
+    //     (Some(label), Some(feed)) => feed.switch_input(&label).await.map_err(|e| e.to_string()),
+    //     (None, _) => {
+    //         debug!("removing mic in set_start_recording_options");
+    //         app.mic_feed.take();
+    //         Ok(())
+    //     }
+    // }
 }
 
 #[tauri::command]
@@ -2116,6 +2147,7 @@ pub async fn run(recording_logging_handle: LoggingHandle) {
                     mic_feed: None,
                     recording_state: RecordingState::None,
                     recording_logging_handle,
+                    mic_feed_actor: None,
                     server_url: GeneralSettingsStore::get(&app)
                         .ok()
                         .flatten()
diff --git a/apps/desktop/src-tauri/src/recording.rs b/apps/desktop/src-tauri/src/recording.rs
index 5dcfb1b97f..ce7bfcaf0b 100644
--- a/apps/desktop/src-tauri/src/recording.rs
+++ b/apps/desktop/src-tauri/src/recording.rs
@@ -17,10 +17,10 @@ use crate::{
     windows::{CapWindowId, ShowCapWindow},
 };
 use cap_fail::fail;
-use cap_media::{feeds::CameraFeed, platform::display_for_window, sources::ScreenCaptureTarget};
 use cap_media::{
-    platform::Bounds,
-    sources::{CaptureScreen, CaptureWindow},
+    feeds::CameraFeed,
+    platform::{Bounds, display_for_window},
+    sources::{CaptureScreen, CaptureWindow, ScreenCaptureTarge},
 };
 use cap_project::{
     CursorClickEvent, Platform, ProjectConfiguration, RecordingMeta, RecordingMetaInner,
diff --git a/apps/desktop/src/routes/(window-chrome)/(main).tsx b/apps/desktop/src/routes/(window-chrome)/(main).tsx
index 188a93f7e6..e973977834 100644
--- a/apps/desktop/src/routes/(window-chrome)/(main).tsx
+++ b/apps/desktop/src/routes/(window-chrome)/(main).tsx
@@ -856,6 +856,7 @@ function MicrophoneSelect(props: {
 	return (
 		<div class="flex flex-col gap-[0.25rem] items-stretch text-[--text-primary]">
 			<button
+				type="button"
 				disabled={!!currentRecording.data || props.disabled}
 				class="relative flex flex-row items-center h-[2rem] px-[0.375rem] gap-[0.375rem] border rounded-lg border-gray-3 w-full disabled:text-gray-11 transition-colors KSelect overflow-hidden z-10"
 				onClick={() => {
diff --git a/crates/cpal-ffmpeg/Cargo.toml b/crates/cpal-ffmpeg/Cargo.toml
new file mode 100644
index 0000000000..4ea431bd53
--- /dev/null
+++ b/crates/cpal-ffmpeg/Cargo.toml
@@ -0,0 +1,11 @@
+[package]
+name = "cap-cpal-ffmpeg"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+cpal.workspace = true
+ffmpeg.workspace = true
+
+[lints]
+workspace = true
diff --git a/crates/cpal-ffmpeg/src/lib.rs b/crates/cpal-ffmpeg/src/lib.rs
new file mode 100644
index 0000000000..0074e82591
--- /dev/null
+++ b/crates/cpal-ffmpeg/src/lib.rs
@@ -0,0 +1,81 @@
+use cpal::{SampleFormat, StreamConfig};
+use ffmpeg::format::{Sample, sample};
+
+pub trait DataExt {
+    fn as_ffmpeg(&self, config: &StreamConfig) -> ffmpeg::frame::Audio;
+}
+
+impl DataExt for ::cpal::Data {
+    fn as_ffmpeg(&self, config: &StreamConfig) -> ffmpeg::frame::Audio {
+        let format_typ = sample::Type::Packed;
+
+        let sample_size = self.sample_format().sample_size();
+        let sample_count = self.bytes().len() / (sample_size * config.channels as usize);
+
+        let mut ffmpeg_frame = ffmpeg::frame::Audio::new(
+            match self.sample_format() {
+                SampleFormat::F32 => Sample::F32(format_typ),
+                SampleFormat::F64 => Sample::F64(format_typ),
+                SampleFormat::I16 => Sample::I16(format_typ),
+                SampleFormat::I32 => Sample::I32(format_typ),
+                SampleFormat::U8 => Sample::U8(format_typ),
+                _ => panic!("Unsupported sample format"),
+            },
+            sample_count,
+            ffmpeg::ChannelLayout::default(config.channels as i32),
+        );
+
+        if matches!(format_typ, sample::Type::Planar) {
+            for i in 0..config.channels {
+                let plane_size = sample_count * sample_size as usize;
+                let base = (i as usize) * plane_size;
+
+                ffmpeg_frame
+                    .plane_data_mut(i as usize)
+                    .copy_from_slice(&self.bytes()[base..base + plane_size]);
+            }
+        } else {
+            ffmpeg_frame.data_mut(0).copy_from_slice(self.bytes());
+        }
+
+        ffmpeg_frame.set_rate(config.sample_rate.0);
+
+        ffmpeg_frame
+    }
+}
+
+pub trait PlanarData {
+    fn plane_data(&self, index: usize) -> &[u8];
+
+    fn plane_data_mut(&mut self, index: usize) -> &mut [u8];
+}
+
+impl PlanarData for ffmpeg::frame::Audio {
+    #[inline]
+    fn plane_data(&self, index: usize) -> &[u8] {
+        if index >= self.planes() {
+            panic!("out of bounds");
+        }
+
+        unsafe {
+            std::slice::from_raw_parts(
+                (*self.as_ptr()).data[index],
+                (*self.as_ptr()).linesize[0] as usize,
+            )
+        }
+    }
+
+    #[inline]
+    fn plane_data_mut(&mut self, index: usize) -> &mut [u8] {
+        if index >= self.planes() {
+            panic!("out of bounds");
+        }
+
+        unsafe {
+            std::slice::from_raw_parts_mut(
+                (*self.as_mut_ptr()).data[index],
+                (*self.as_ptr()).linesize[0] as usize,
+            )
+        }
+    }
+}
diff --git a/crates/media/Cargo.toml b/crates/media/Cargo.toml
index 1f0dcf0236..8c08577d6e 100644
--- a/crates/media/Cargo.toml
+++ b/crates/media/Cargo.toml
@@ -17,6 +17,7 @@ cap-flags = { path = "../flags" }
 cap-audio = { path = "../audio" }
 cap-camera = { path = "../camera", features = ["specta", "serde"] }
 cap-camera-ffmpeg = { path = "../camera-ffmpeg" }
+cap-cpal-ffmpeg = { path = "../cpal-ffmpeg" }
 cap-fail = { path = "../fail" }
 cap-media-encoders = { path = "../media-encoders" }
 cap-media-info = { path = "../media-info" }
diff --git a/crates/media/src/feeds/microphone.rs b/crates/media/src/feeds/microphone.rs
new file mode 100644
index 0000000000..a55d8113c2
--- /dev/null
+++ b/crates/media/src/feeds/microphone.rs
@@ -0,0 +1,225 @@
+use std::sync::mpsc;
+
+use cap_media_info::ffmpeg_sample_format_for;
+use cpal::{
+    BuildStreamError, Device, InputCallbackInfo, PlayStreamError, SampleFormat, StreamConfig,
+    StreamError, SupportedStreamConfig,
+    traits::{DeviceTrait, HostTrait, StreamTrait},
+};
+use flume::TrySendError;
+use futures::channel::oneshot;
+use indexmap::IndexMap;
+use kameo::prelude::*;
+use tracing::{debug, error, info, trace, warn};
+
+pub type MicrophonesMap = IndexMap<String, (Device, SupportedStreamConfig)>;
+
+#[derive(Clone)]
+pub struct AudioInputSamples {
+    pub data: Vec<u8>,
+    pub format: SampleFormat,
+    pub info: InputCallbackInfo,
+}
+
+#[derive(Actor)]
+pub struct MicrophoneFeed {
+    state: Option<(StreamConfig, mpsc::SyncSender<()>)>,
+    senders: Vec<flume::Sender<AudioInputSamples>>,
+    error_sender: flume::Sender<StreamError>,
+}
+
+impl MicrophoneFeed {
+    pub fn new(error_sender: flume::Sender<StreamError>) -> Self {
+        Self {
+            state: None,
+            senders: Vec::new(),
+            error_sender,
+        }
+    }
+
+    pub fn list() -> MicrophonesMap {
+        let host = cpal::default_host();
+        let mut device_map = IndexMap::new();
+
+        let get_usable_device = |device: Device| {
+            device
+                .supported_input_configs()
+                .map_err(|error| {
+                    error!(
+                        "Error getting supported input configs for device: {}",
+                        error
+                    );
+                    error
+                })
+                .ok()
+                .and_then(|configs| {
+                    let mut configs = configs.collect::<Vec<_>>();
+                    configs.sort_by(|a, b| {
+                        b.sample_format()
+                            .sample_size()
+                            .cmp(&a.sample_format().sample_size())
+                            .then(b.max_sample_rate().cmp(&a.max_sample_rate()))
+                    });
+                    configs
+                        .into_iter()
+                        .filter(|c| {
+                            c.min_sample_rate().0 <= 48000 && c.max_sample_rate().0 <= 48000
+                        })
+                        .find(|c| ffmpeg_sample_format_for(c.sample_format()).is_some())
+                })
+                .and_then(|config| {
+                    device
+                        .name()
+                        .ok()
+                        .map(|name| (name, device, config.with_max_sample_rate()))
+                })
+        };
+
+        if let Some((name, device, config)) =
+            host.default_input_device().and_then(get_usable_device)
+        {
+            device_map.insert(name, (device, config));
+        } else {
+            warn!("No default input device found or it's not usable");
+        }
+
+        match host.input_devices() {
+            Ok(devices) => {
+                for (name, device, config) in devices.filter_map(get_usable_device) {
+                    device_map.entry(name).or_insert((device, config));
+                }
+            }
+            Err(error) => {
+                error!("Could not access audio input devices: {}", error);
+            }
+        }
+
+        device_map
+    }
+}
+
+pub struct SetInput {
+    pub label: String,
+}
+
+#[derive(Debug)]
+pub enum SetInputError {
+    DeviceNotFound,
+    BuildStreamCrashed,
+    BuildStream(BuildStreamError),
+    PlayStream(PlayStreamError),
+}
+
+impl Message<SetInput> for MicrophoneFeed {
+    type Reply = Result<StreamConfig, SetInputError>;
+
+    async fn handle(&mut self, msg: SetInput, ctx: &mut Context<Self, Self::Reply>) -> Self::Reply {
+        trace!("MicrophoneFeed.SetInput('{}')", &msg.label);
+
+        let Some((device, config)) = Self::list().swap_remove(&msg.label) else {
+            return Err(SetInputError::DeviceNotFound);
+        };
+
+        let sample_format = config.sample_format();
+        let stream_config: StreamConfig = config.into();
+
+        let (ready_tx, ready_rx) = oneshot::channel();
+        let (done_tx, done_rx) = mpsc::sync_channel(0);
+
+        let _stream_config = stream_config.clone();
+        let actor_ref = ctx.actor_ref();
+        let error_sender = self.error_sender.clone();
+
+        std::thread::spawn(move || {
+            let stream = match device.build_input_stream_raw(
+                &_stream_config,
+                sample_format,
+                {
+                    let actor_ref = actor_ref.clone();
+                    move |data, info| {
+                        let _ = actor_ref
+                            .tell(AudioInputSamples {
+                                data: data.bytes().to_vec(),
+                                format: data.sample_format(),
+                                info: info.clone(),
+                            })
+                            .try_send();
+                    }
+                },
+                move |e| {
+                    error!("Microphone stream error: {e}");
+
+                    let _ = error_sender.send(e).is_err();
+                    actor_ref.kill();
+                },
+                None,
+            ) {
+                Ok(stream) => stream,
+                Err(e) => {
+                    let _ = ready_tx.send(Err(SetInputError::BuildStream(e)));
+                    return;
+                }
+            };
+
+            if let Err(e) = stream.play() {
+                let _ = ready_tx.send(Err(SetInputError::PlayStream(e)));
+                return;
+            }
+
+            let _ = ready_tx.send(Ok(()));
+
+            match done_rx.recv() {
+                Ok(_) => {
+                    info!("Microphone actor shut down, ending stream");
+                }
+                Err(_) => {
+                    info!("Microphone actor unreachable, ending stream");
+                }
+            }
+        });
+
+        ready_rx
+            .await
+            .map_err(|_| SetInputError::BuildStreamCrashed)??;
+
+        self.state = Some((stream_config.clone(), done_tx));
+
+        Ok(stream_config)
+    }
+}
+
+pub struct AddSender(pub flume::Sender<AudioInputSamples>);
+
+impl Message<AddSender> for MicrophoneFeed {
+    type Reply = ();
+
+    async fn handle(&mut self, msg: AddSender, _: &mut Context<Self, Self::Reply>) -> Self::Reply {
+        self.senders.push(msg.0);
+    }
+}
+
+impl Message<AudioInputSamples> for MicrophoneFeed {
+    type Reply = ();
+
+    async fn handle(
+        &mut self,
+        msg: AudioInputSamples,
+        _: &mut Context<Self, Self::Reply>,
+    ) -> Self::Reply {
+        let mut to_remove = vec![];
+
+        for (i, sender) in self.senders.iter().enumerate() {
+            if let Err(TrySendError::Disconnected(_)) = sender.try_send(msg.clone()) {
+                warn!("Audio sender {} disconnected, will be removed", i);
+                to_remove.push(i);
+            };
+        }
+
+        if !to_remove.is_empty() {
+            debug!("Removing {} disconnected audio senders", to_remove.len());
+            for i in to_remove.into_iter().rev() {
+                self.senders.swap_remove(i);
+            }
+        }
+    }
+}
diff --git a/crates/media/src/feeds/mod.rs b/crates/media/src/feeds/mod.rs
index 7be4e726da..8d3043532a 100644
--- a/crates/media/src/feeds/mod.rs
+++ b/crates/media/src/feeds/mod.rs
@@ -1,6 +1,7 @@
 mod audio;
 mod audio_input;
 mod camera;
+pub mod microphone;
 
 pub use audio::*;
 pub use audio_input::*;
diff --git a/crates/media/src/sources/audio_input.rs b/crates/media/src/sources/audio_input.rs
index 9cfec73fd4..c26d9bf947 100644
--- a/crates/media/src/sources/audio_input.rs
+++ b/crates/media/src/sources/audio_input.rs
@@ -1,17 +1,16 @@
-use std::time::SystemTime;
-
 use cap_fail::fail;
 use cap_media_info::AudioInfo;
 use cpal::{Device, StreamInstant, SupportedStreamConfig};
 use ffmpeg_sys_next::AV_TIME_BASE_Q;
 use flume::{Receiver, Sender};
 use indexmap::IndexMap;
+use std::time::SystemTime;
 use tracing::{error, info};
 
-use crate::feeds::{AudioInputConnection, AudioInputFeed, AudioInputSamples};
 use crate::{
     MediaError,
     data::FFAudio,
+    feeds::{AudioInputConnection, AudioInputFeed, AudioInputSamples},
     pipeline::{
         clock::{LocalTimestamp, RealTimeClock},
         control::Control,
diff --git a/crates/recording/Cargo.toml b/crates/recording/Cargo.toml
index 9ab1170c60..c505619ba6 100644
--- a/crates/recording/Cargo.toml
+++ b/crates/recording/Cargo.toml
@@ -37,6 +37,7 @@ futures = { workspace = true }
 tokio-util = "0.7.15"
 sha2 = "0.10.9"
 hex = "0.4.3"
+kameo = "0.17.2"
 
 [target.'cfg(target_os = "macos")'.dependencies]
 screencapturekit = "0.3.5"
diff --git a/crates/recording/src/lib.rs b/crates/recording/src/lib.rs
index e4258a43ce..6524b2f6a9 100644
--- a/crates/recording/src/lib.rs
+++ b/crates/recording/src/lib.rs
@@ -7,7 +7,13 @@ pub use studio_recording::{
     CompletedStudioRecording, StudioRecordingHandle, spawn_studio_recording_actor,
 };
 
-use cap_media::{MediaError, feeds::AudioInputFeed, platform::Bounds, sources::*};
+use cap_media::{
+    MediaError,
+    feeds::{AudioInputFeed, microphone::MicrophoneFeed},
+    platform::Bounds,
+    sources::*,
+};
+use kameo::actor::ActorRef;
 use serde::{Deserialize, Serialize};
 use thiserror::Error;
 
@@ -34,7 +40,7 @@ pub struct RecordingOptions {
 pub struct RecordingBaseInputs<'a> {
     pub capture_target: ScreenCaptureTarget,
     pub capture_system_audio: bool,
-    pub mic_feed: &'a Option<AudioInputFeed>,
+    pub mic_feed: &'a Option<ActorRef<MicrophoneFeed>>,
 }
 
 #[derive(specta::Type, Serialize, Deserialize, Clone, Debug)]

From ddbf0b7bab4c75955ae9ac5e27e7b1ed85d30661 Mon Sep 17 00:00:00 2001
From: Brendan Allan <brendonovich@outlook.com>
Date: Mon, 25 Aug 2025 15:09:46 +0800
Subject: [PATCH 2/7] blocking mic feed actor

---
 apps/cli/src/record.rs                    |   2 +-
 apps/desktop/src-tauri/src/audio_meter.rs |   9 +-
 apps/desktop/src-tauri/src/lib.rs         |  96 +++---
 apps/desktop/src-tauri/src/recording.rs   |  18 +-
 crates/media/src/feeds/audio_input.rs     | 350 ----------------------
 crates/media/src/feeds/microphone.rs      |  96 +++++-
 crates/media/src/feeds/mod.rs             |   2 -
 crates/media/src/sources/audio_input.rs   |  30 +-
 crates/recording/src/capture_pipeline.rs  |  12 +-
 crates/recording/src/instant_recording.rs |  26 +-
 crates/recording/src/lib.rs               |   7 +-
 crates/recording/src/studio_recording.rs  |  33 +-
 crates/scap-direct3d/examples/cli.rs      |  46 +--
 packages/ui-solid/src/auto-imports.d.ts   |   1 +
 14 files changed, 230 insertions(+), 498 deletions(-)
 delete mode 100644 crates/media/src/feeds/audio_input.rs

diff --git a/apps/cli/src/record.rs b/apps/cli/src/record.rs
index 92d9b8bb11..4a14a765fd 100644
--- a/apps/cli/src/record.rs
+++ b/apps/cli/src/record.rs
@@ -65,7 +65,7 @@ impl RecordStart {
             cap_recording::RecordingBaseInputs {
                 capture_target: target_info,
                 capture_system_audio: self.system_audio,
-                mic_feed: &None,
+                mic_feed: None,
             },
             camera.map(|c| Arc::new(Mutex::new(c))),
             false,
diff --git a/apps/desktop/src-tauri/src/audio_meter.rs b/apps/desktop/src-tauri/src/audio_meter.rs
index 8d69bf0204..24cc0f6224 100644
--- a/apps/desktop/src-tauri/src/audio_meter.rs
+++ b/apps/desktop/src-tauri/src/audio_meter.rs
@@ -1,4 +1,4 @@
-use cap_media::feeds::{AudioInputSamples, AudioInputSamplesReceiver};
+use cap_media::feeds::microphone::MicrophoneSamples;
 use cpal::{SampleFormat, StreamInstant};
 use keyed_priority_queue::KeyedPriorityQueue;
 use serde::{Deserialize, Serialize};
@@ -15,7 +15,10 @@ const MIN_DB: f64 = -96.0;
 #[derive(Deserialize, specta::Type, Serialize, tauri_specta::Event, Debug, Clone)]
 pub struct AudioInputLevelChange(f64);
 
-pub fn spawn_event_emitter(app_handle: AppHandle, audio_input_rx: AudioInputSamplesReceiver) {
+pub fn spawn_event_emitter(
+    app_handle: AppHandle,
+    audio_input_rx: flume::Receiver<MicrophoneSamples>,
+) {
     let mut time_window = VolumeMeter::new(0.2);
     tokio::spawn(async move {
         while let Ok(samples) = audio_input_rx.recv_async().await {
@@ -106,7 +109,7 @@ fn db_fs(data: impl Iterator<Item = f64>) -> f64 {
     (20.0 * (max as f64 / MAX_AMPLITUDE_F32).log10()).clamp(MIN_DB, 0.0)
 }
 
-fn samples_to_f64(samples: &AudioInputSamples) -> impl Iterator<Item = f64> + use<'_> {
+fn samples_to_f64(samples: &MicrophoneSamples) -> impl Iterator<Item = f64> + use<'_> {
     samples
         .data
         .chunks(samples.format.sample_size())
diff --git a/apps/desktop/src-tauri/src/lib.rs b/apps/desktop/src-tauri/src/lib.rs
index 15021515ad..d7de2a8e3e 100644
--- a/apps/desktop/src-tauri/src/lib.rs
+++ b/apps/desktop/src-tauri/src/lib.rs
@@ -28,8 +28,8 @@ use camera::{CameraPreview, CameraWindowState};
 use cap_editor::{EditorInstance, EditorState};
 use cap_media::{
     feeds::{
-        self, AudioInputFeed, AudioInputSamplesSender, CameraFeed, RawCameraFrame,
-        microphone::MicrophoneFeed,
+        self, CameraFeed, RawCameraFrame,
+        microphone::{self, MicrophoneFeed},
     },
     platform::Bounds,
     sources::ScreenCaptureTarget,
@@ -103,10 +103,6 @@ pub struct App {
     camera_feed: Option<Arc<Mutex<CameraFeed>>>,
     #[serde(skip)]
     camera_feed_initialization: Option<mpsc::Sender<()>>,
-    // #[serde(skip)]
-    // mic_feed: Option<AudioInputFeed>,
-    #[serde(skip)]
-    mic_samples_tx: AudioInputSamplesSender,
     #[serde(skip)]
     handle: AppHandle,
     #[serde(skip)]
@@ -114,7 +110,7 @@ pub struct App {
     #[serde(skip)]
     recording_logging_handle: LoggingHandle,
     #[serde(skip)]
-    mic_feed_actor: Option<ActorRef<feeds::microphone::MicrophoneFeed>>,
+    mic_feed_actor: ActorRef<feeds::microphone::MicrophoneFeed>,
     server_url: String,
 }
 
@@ -221,56 +217,20 @@ async fn set_mic_input(state: MutableState<'_, App>, label: Option<String>) -> R
 
     match label {
         None => {
-            app.mic_feed_actor.take();
+            let _ = app.mic_feed_actor.ask(microphone::RemoveInput).await;
+
+            Ok(())
         }
         Some(label) => {
-            let mic_feed_actor = app.mic_feed_actor.get_or_insert_with(|| {
-                let (error_tx, error_rx) = flume::bounded(1);
-
-                // TODO: make this part of a global actor one day
-                tokio::spawn(async move {
-                    let Ok(err) = error_rx.recv_async().await else {
-                        return;
-                    };
-
-                    error!("Mic feed actor error: {err}");
-                });
-
-                MicrophoneFeed::spawn(MicrophoneFeed::new(error_tx))
-            });
-
-            let _ = mic_feed_actor
-                .ask(feeds::microphone::AddSender(app.mic_samples_tx.clone()))
-                .await;
-
-            drop(app);
-
-            let _config = mic_feed_actor
+            let _ = app
+                .mic_feed_actor
                 .ask(feeds::microphone::SetInput { label })
                 .await
                 .map_err(|e| e.to_string())?;
+
+            Ok(())
         }
     }
-
-    // match (label, &mut app.mic_feed) {
-    //     (Some(label), None) => {
-    //         AudioInputFeed::init(&label)
-    //             .await
-    //             .map_err(|e| e.to_string())
-    //             .map(async |feed| {
-    //                 feed.add_sender(app.mic_samples_tx.clone()).await.unwrap();
-    //                 app.mic_feed = Some(feed);
-    //             })
-    //             .transpose_async()
-    //             .await
-    //     }
-    //     (Some(label), Some(feed)) => feed.switch_input(&label).await.map_err(|e| e.to_string()),
-    //     (None, _) => {
-    //         debug!("removing mic in set_start_recording_options");
-    //         app.mic_feed.take();
-    //         Ok(())
-    //     }
-    // }
 }
 
 #[tauri::command]
@@ -1126,7 +1086,7 @@ async fn list_audio_devices() -> Result<Vec<String>, ()> {
         return Ok(vec![]);
     }
 
-    Ok(AudioInputFeed::list_devices().keys().cloned().collect())
+    Ok(MicrophoneFeed::list().keys().cloned().collect())
 }
 
 #[derive(Serialize, Type, tauri_specta::Event, Debug, Clone)]
@@ -2046,7 +2006,28 @@ pub async fn run(recording_logging_handle: LoggingHandle) {
 
     let (camera_tx, camera_ws_port, _shutdown) = camera_legacy::create_camera_preview_ws().await;
 
-    let (audio_input_tx, audio_input_rx) = AudioInputFeed::create_channel();
+    let (mic_samples_tx, mic_samples_rx) = flume::bounded(8);
+
+    let mic_feed = {
+        let (error_tx, error_rx) = flume::bounded(1);
+
+        let mic_feed = MicrophoneFeed::spawn(MicrophoneFeed::new(error_tx));
+
+        // TODO: make this part of a global actor one day
+        tokio::spawn(async move {
+            let Ok(err) = error_rx.recv_async().await else {
+                return;
+            };
+
+            error!("Mic feed actor error: {err}");
+        });
+
+        let _ = mic_feed
+            .ask(feeds::microphone::AddSender(mic_samples_tx))
+            .await;
+
+        mic_feed
+    };
 
     tauri::async_runtime::set(tokio::runtime::Handle::current());
 
@@ -2143,11 +2124,9 @@ pub async fn run(recording_logging_handle: LoggingHandle) {
                     handle: app.clone(),
                     camera_feed: None,
                     camera_feed_initialization: None,
-                    mic_samples_tx: audio_input_tx,
-                    mic_feed: None,
                     recording_state: RecordingState::None,
                     recording_logging_handle,
-                    mic_feed_actor: None,
+                    mic_feed_actor: mic_feed,
                     server_url: GeneralSettingsStore::get(&app)
                         .ok()
                         .flatten()
@@ -2196,7 +2175,7 @@ pub async fn run(recording_logging_handle: LoggingHandle) {
                 }
             });
 
-            audio_meter::spawn_event_emitter(app.clone(), audio_input_rx);
+            audio_meter::spawn_event_emitter(app.clone(), mic_samples_rx);
 
             tray::create_tray(&app).unwrap();
 
@@ -2236,7 +2215,10 @@ pub async fn run(recording_logging_handle: LoggingHandle) {
                                     let app_state = &mut *state.write().await;
 
                                     if !app_state.is_recording_active_or_pending() {
-                                        app_state.mic_feed.take();
+                                        let _ = app_state
+                                            .mic_feed_actor
+                                            .ask(microphone::RemoveInput)
+                                            .await;
                                         app_state.camera_feed.take();
 
                                         if let Some(camera) = CapWindowId::Camera.get(&app) {
diff --git a/apps/desktop/src-tauri/src/recording.rs b/apps/desktop/src-tauri/src/recording.rs
index ce7bfcaf0b..6f268afbb6 100644
--- a/apps/desktop/src-tauri/src/recording.rs
+++ b/apps/desktop/src-tauri/src/recording.rs
@@ -18,9 +18,12 @@ use crate::{
 };
 use cap_fail::fail;
 use cap_media::{
-    feeds::CameraFeed,
+    feeds::{
+        CameraFeed,
+        microphone::{self, SetInput},
+    },
     platform::{Bounds, display_for_window},
-    sources::{CaptureScreen, CaptureWindow, ScreenCaptureTarge},
+    sources::{CaptureScreen, CaptureWindow, ScreenCaptureTarget},
 };
 use cap_project::{
     CursorClickEvent, Platform, ProjectConfiguration, RecordingMeta, RecordingMetaInner,
@@ -380,10 +383,17 @@ pub async fn start_recording(
             fail!("recording::spawn_actor");
             let mut state = state_mtx.write().await;
 
+            use kameo::error::SendError;
+            let mic_feed = match state.mic_feed_actor.ask(microphone::Lock).await {
+                Ok(lock) => Some(Arc::new(lock)),
+                Err(SendError::HandlerError(microphone::LockFeedError::NoInput)) => None,
+                Err(e) => return Err(e.to_string()),
+            };
+
             let base_inputs = cap_recording::RecordingBaseInputs {
                 capture_target: inputs.capture_target,
                 capture_system_audio: inputs.capture_system_audio,
-                mic_feed: &state.mic_feed,
+                mic_feed,
             };
 
             let (actor, actor_done_rx) = match inputs.mode {
@@ -643,7 +653,7 @@ async fn handle_recording_end(
             let _ = v.close();
         }
         app.camera_feed.take();
-        app.mic_feed.take();
+        let _ = app.mic_feed_actor.ask(microphone::RemoveInput).await;
     }
 
     CurrentRecordingChanged.emit(&handle).ok();
diff --git a/crates/media/src/feeds/audio_input.rs b/crates/media/src/feeds/audio_input.rs
deleted file mode 100644
index d74378b384..0000000000
--- a/crates/media/src/feeds/audio_input.rs
+++ /dev/null
@@ -1,350 +0,0 @@
-use cap_fail::fail_err;
-use cap_media_info::{AudioInfo, ffmpeg_sample_format_for};
-use cpal::traits::{DeviceTrait, HostTrait, StreamTrait};
-use cpal::{Device, InputCallbackInfo, SampleFormat, StreamConfig, SupportedStreamConfig};
-use flume::{Receiver, Sender, TrySendError};
-use indexmap::IndexMap;
-use tracing::{debug, error, info, trace, warn};
-
-use crate::MediaError;
-
-#[derive(Clone)]
-pub struct AudioInputSamples {
-    pub data: Vec<u8>,
-    pub format: SampleFormat,
-    pub info: InputCallbackInfo,
-}
-
-pub enum AudioInputControl {
-    Switch(String, Sender<Result<SupportedStreamConfig, MediaError>>),
-    AttachSender(AudioInputSamplesSender),
-    Shutdown,
-}
-
-pub struct AudioInputConnection {
-    control: Sender<AudioInputControl>,
-}
-
-impl AudioInputConnection {
-    pub fn attach(&self) -> Receiver<AudioInputSamples> {
-        let (sender, receiver) = flume::bounded(5);
-        self.control
-            .send(AudioInputControl::AttachSender(sender))
-            .unwrap();
-
-        receiver
-    }
-}
-
-pub type AudioInputSamplesSender = Sender<AudioInputSamples>;
-pub type AudioInputSamplesReceiver = Receiver<AudioInputSamples>;
-
-pub type AudioInputDeviceMap = IndexMap<String, (Device, SupportedStreamConfig)>;
-
-pub const MAX_AUDIO_CHANNELS: u16 = 2;
-
-#[derive(Clone)]
-pub struct AudioInputFeed {
-    pub control_tx: Sender<AudioInputControl>,
-    audio_info: AudioInfo,
-    // rx: Receiver<AudioInputSamples>,
-}
-
-impl AudioInputFeed {
-    pub fn create_channel() -> (AudioInputSamplesSender, AudioInputSamplesReceiver) {
-        flume::bounded(60)
-    }
-
-    pub async fn init(selected_input: &str) -> Result<Self, MediaError> {
-        trace!("Initializing audio input feed with device");
-        debug!(selected_input);
-
-        fail_err!(
-            "media::feeds::audio_input::init",
-            MediaError::Any("".into())
-        );
-
-        let (device, config) = Self::list_devices()
-            .swap_remove_entry(selected_input)
-            .map(|(device_name, (device, config))| {
-                info!(
-                    "Using audio device: {} with config: {:?}",
-                    device_name, config
-                );
-                (device, config)
-            })
-            .ok_or_else(|| {
-                error!("Failed to find audio device: {}", selected_input);
-                MediaError::DeviceUnreachable(selected_input.to_string())
-            })?;
-
-        let audio_info = AudioInfo::from_stream_config(&config);
-
-        debug!("Created audio info: {:?}", audio_info);
-        let (control_tx, control_rx) = flume::bounded(1);
-
-        std::thread::spawn(|| start_capturing(device, config, control_rx));
-        info!("Started audio capture thread");
-
-        Ok(Self {
-            control_tx,
-            audio_info,
-        })
-    }
-
-    pub fn list_devices() -> AudioInputDeviceMap {
-        let host = cpal::default_host();
-        let mut device_map = IndexMap::new();
-
-        let get_usable_device = |device: Device| {
-            device
-                .supported_input_configs()
-                .map_err(|error| {
-                    error!(
-                        "Error getting supported input configs for device: {}",
-                        error
-                    );
-                    error
-                })
-                .ok()
-                .and_then(|configs| {
-                    let mut configs = configs.collect::<Vec<_>>();
-                    configs.sort_by(|a, b| {
-                        b.sample_format()
-                            .sample_size()
-                            .cmp(&a.sample_format().sample_size())
-                            .then(b.max_sample_rate().cmp(&a.max_sample_rate()))
-                    });
-                    configs
-                        .into_iter()
-                        .filter(|c| {
-                            c.min_sample_rate().0 <= 48000 && c.max_sample_rate().0 <= 48000
-                        })
-                        .find(|c| ffmpeg_sample_format_for(c.sample_format()).is_some())
-                })
-                .and_then(|config| {
-                    device
-                        .name()
-                        .ok()
-                        .map(|name| (name, device, config.with_max_sample_rate()))
-                })
-        };
-
-        if let Some((name, device, config)) =
-            host.default_input_device().and_then(get_usable_device)
-        {
-            device_map.insert(name, (device, config));
-        } else {
-            warn!("No default input device found or it's not usable");
-        }
-
-        match host.input_devices() {
-            Ok(devices) => {
-                for (name, device, config) in devices.filter_map(get_usable_device) {
-                    device_map.entry(name).or_insert((device, config));
-                }
-            }
-            Err(error) => {
-                error!("Could not access audio input devices: {}", error);
-            }
-        }
-
-        device_map
-    }
-
-    pub async fn switch_input(&mut self, name: &str) -> Result<(), MediaError> {
-        fail_err!(
-            "media::feeds::audio_input::switch_input",
-            MediaError::Any("".into())
-        );
-
-        let (tx, rx) = flume::bounded(1);
-
-        self.control_tx
-            .send_async(AudioInputControl::Switch(name.to_string(), tx))
-            .await
-            .map_err(|error| {
-                eprintln!("Error while switching audio input: {error}");
-                MediaError::TaskLaunch("Failed to switch audio input".into())
-            })?;
-
-        let config = rx.recv_async().await.map_err(|error| {
-            eprintln!("Error while switching audio input: {error}");
-            MediaError::TaskLaunch("Failed to switch audio input".into())
-        })??;
-
-        self.audio_info = AudioInfo::from_stream_config(&config);
-
-        Ok(())
-    }
-
-    pub async fn add_sender(&self, sender: AudioInputSamplesSender) -> Result<(), MediaError> {
-        self.control_tx
-            .send_async(AudioInputControl::AttachSender(sender))
-            .await
-            .map_err(|error| {
-                eprintln!("Error while attaching audio input sender: {error}");
-                MediaError::TaskLaunch("Failed to attach audio input sender".into())
-            })?;
-
-        Ok(())
-    }
-
-    pub fn audio_info(&self) -> AudioInfo {
-        self.audio_info
-    }
-
-    pub fn create_connection(&self) -> AudioInputConnection {
-        AudioInputConnection {
-            control: self.control_tx.clone(),
-        }
-    }
-}
-
-fn start_capturing(
-    mut device: Device,
-    mut config: SupportedStreamConfig,
-    control: Receiver<AudioInputControl>,
-) {
-    debug!(
-        "Starting audio capture with device: {:?}, config: {:?}",
-        device.name(),
-        config
-    );
-    let mut senders: Vec<AudioInputSamplesSender> = vec![];
-
-    loop {
-        let (tx, rx) = flume::bounded(4);
-        debug!("Building input stream with config: {:?}", config);
-
-        let stream_config: StreamConfig = config.clone().into();
-        let stream = match device.build_input_stream_raw(
-            &stream_config,
-            config.sample_format(),
-            move |data, info| {
-                if let Err(e) = tx.send(AudioInputSamples {
-                    data: data.bytes().to_vec(),
-                    format: data.sample_format(),
-                    info: info.clone(),
-                }) {
-                    error!("Failed to send audio samples: {}", e);
-                }
-            },
-            |e| {
-                error!("Error in audio input stream: {}", e);
-            },
-            None,
-        ) {
-            Ok(stream) => {
-                info!("Successfully built audio input stream");
-                stream
-            }
-            Err(err) => {
-                error!("Failed to build audio input stream: {}", err);
-                // Sleep briefly to avoid tight error loop
-                std::thread::sleep(std::time::Duration::from_secs(1));
-                continue;
-            }
-        };
-
-        // Try to play the stream
-        if let Err(e) = stream.play() {
-            error!("Failed to start audio stream playback: {}", e);
-            continue;
-        }
-        info!("Audio stream playback started");
-
-        loop {
-            match control.try_recv() {
-                Ok(AudioInputControl::Switch(name, response)) => {
-                    if device.name().unwrap() == name {
-                        response.send(Ok(config.clone())).unwrap();
-                        continue;
-                    }
-
-                    debug!("Switching audio device to: {}", name);
-                    // list_devices hangs if the stream isn't dropped
-                    drop(stream);
-                    let Some(items) = AudioInputFeed::list_devices().swap_remove_entry(&name).map(
-                        |(device_name, (device, config))| {
-                            info!(
-                                "Switched to audio device: {} with config: {:?}",
-                                device_name, config
-                            );
-                            (device, config)
-                        },
-                    ) else {
-                        error!("Failed to find audio device: {}", name);
-                        response
-                            .send(Err(MediaError::DeviceUnreachable(name)))
-                            .unwrap();
-                        break;
-                    };
-
-                    device = items.0;
-                    config = items.1;
-
-                    response.send(Ok(config.clone())).unwrap();
-                    break;
-                }
-                Ok(AudioInputControl::Shutdown) => {
-                    debug!("Received shutdown signal for audio capture");
-                    return;
-                }
-                Ok(AudioInputControl::AttachSender(sender)) => {
-                    senders.push(sender);
-                    info!("New audio sender attached");
-                }
-                Err(flume::TryRecvError::Disconnected) => {
-                    warn!("Control receiver is unreachable! Shutting down audio capture");
-                    return;
-                }
-                Err(flume::TryRecvError::Empty) => {
-                    // No signal received, nothing to do
-                }
-            }
-
-            match rx.recv() {
-                Ok(mut data) => {
-                    let mut to_remove = vec![];
-
-                    if config.channels() > MAX_AUDIO_CHANNELS {
-                        let mut new_data = Vec::with_capacity(
-                            MAX_AUDIO_CHANNELS as usize
-                                * (data.data.len() / config.channels() as usize),
-                        );
-
-                        let sample_size = data.format.sample_size();
-
-                        for sample in data.data.chunks(sample_size * config.channels() as usize) {
-                            new_data.extend_from_slice(
-                                &sample[0..sample_size * MAX_AUDIO_CHANNELS as usize],
-                            );
-                        }
-
-                        data.data = new_data;
-                    }
-
-                    for (i, sender) in senders.iter().enumerate() {
-                        if let Err(TrySendError::Disconnected(_)) = sender.try_send(data.clone()) {
-                            warn!("Audio sender {} disconnected, will be removed", i);
-                            to_remove.push(i);
-                        };
-                    }
-
-                    if !to_remove.is_empty() {
-                        debug!("Removing {} disconnected audio senders", to_remove.len());
-                        for i in to_remove.into_iter().rev() {
-                            senders.swap_remove(i);
-                        }
-                    }
-                }
-                Err(error) => {
-                    error!("Failed to capture audio samples: {:?}", error);
-                    // Break inner loop to recreate the stream
-                    break;
-                }
-            }
-        }
-    }
-}
diff --git a/crates/media/src/feeds/microphone.rs b/crates/media/src/feeds/microphone.rs
index a55d8113c2..2a4f6a5697 100644
--- a/crates/media/src/feeds/microphone.rs
+++ b/crates/media/src/feeds/microphone.rs
@@ -1,6 +1,6 @@
-use std::sync::mpsc;
+use std::{ops::Deref, sync::mpsc};
 
-use cap_media_info::ffmpeg_sample_format_for;
+use cap_media_info::{AudioInfo, ffmpeg_sample_format_for};
 use cpal::{
     BuildStreamError, Device, InputCallbackInfo, PlayStreamError, SampleFormat, StreamConfig,
     StreamError, SupportedStreamConfig,
@@ -15,7 +15,7 @@ use tracing::{debug, error, info, trace, warn};
 pub type MicrophonesMap = IndexMap<String, (Device, SupportedStreamConfig)>;
 
 #[derive(Clone)]
-pub struct AudioInputSamples {
+pub struct MicrophoneSamples {
     pub data: Vec<u8>,
     pub format: SampleFormat,
     pub info: InputCallbackInfo,
@@ -23,8 +23,8 @@ pub struct AudioInputSamples {
 
 #[derive(Actor)]
 pub struct MicrophoneFeed {
-    state: Option<(StreamConfig, mpsc::SyncSender<()>)>,
-    senders: Vec<flume::Sender<AudioInputSamples>>,
+    state: Option<(SupportedStreamConfig, mpsc::SyncSender<()>)>,
+    senders: Vec<flume::Sender<MicrophoneSamples>>,
     error_sender: flume::Sender<StreamError>,
 }
 
@@ -102,31 +102,34 @@ pub struct SetInput {
     pub label: String,
 }
 
-#[derive(Debug)]
+#[derive(Debug, thiserror::Error)]
 pub enum SetInputError {
+    #[error("DeviceNotFound")]
     DeviceNotFound,
+    #[error("BuildStreamCrashed")]
     BuildStreamCrashed,
+    #[error("BuildStream: {0}")]
     BuildStream(BuildStreamError),
+    #[error("PlayStream: {0}")]
     PlayStream(PlayStreamError),
 }
 
 impl Message<SetInput> for MicrophoneFeed {
-    type Reply = Result<StreamConfig, SetInputError>;
+    type Reply = Result<SupportedStreamConfig, SetInputError>;
 
     async fn handle(&mut self, msg: SetInput, ctx: &mut Context<Self, Self::Reply>) -> Self::Reply {
-        trace!("MicrophoneFeed.SetInput('{}')", &msg.label);
+        trace!("MicrophoneFeed.SetInput('{:?}')", &msg.label);
 
         let Some((device, config)) = Self::list().swap_remove(&msg.label) else {
             return Err(SetInputError::DeviceNotFound);
         };
 
         let sample_format = config.sample_format();
-        let stream_config: StreamConfig = config.into();
 
         let (ready_tx, ready_rx) = oneshot::channel();
         let (done_tx, done_rx) = mpsc::sync_channel(0);
 
-        let _stream_config = stream_config.clone();
+        let _stream_config = config.clone().into();
         let actor_ref = ctx.actor_ref();
         let error_sender = self.error_sender.clone();
 
@@ -138,7 +141,7 @@ impl Message<SetInput> for MicrophoneFeed {
                     let actor_ref = actor_ref.clone();
                     move |data, info| {
                         let _ = actor_ref
-                            .tell(AudioInputSamples {
+                            .tell(MicrophoneSamples {
                                 data: data.bytes().to_vec(),
                                 format: data.sample_format(),
                                 info: info.clone(),
@@ -182,13 +185,25 @@ impl Message<SetInput> for MicrophoneFeed {
             .await
             .map_err(|_| SetInputError::BuildStreamCrashed)??;
 
-        self.state = Some((stream_config.clone(), done_tx));
+        self.state = Some((config.clone(), done_tx));
 
-        Ok(stream_config)
+        Ok(config)
     }
 }
 
-pub struct AddSender(pub flume::Sender<AudioInputSamples>);
+pub struct RemoveInput;
+
+impl Message<RemoveInput> for MicrophoneFeed {
+    type Reply = ();
+
+    async fn handle(&mut self, _: RemoveInput, _: &mut Context<Self, Self::Reply>) -> Self::Reply {
+        if let Some((_, done_tx)) = self.state.take() {
+            let _ = done_tx.send(());
+        }
+    }
+}
+
+pub struct AddSender(pub flume::Sender<MicrophoneSamples>);
 
 impl Message<AddSender> for MicrophoneFeed {
     type Reply = ();
@@ -198,12 +213,12 @@ impl Message<AddSender> for MicrophoneFeed {
     }
 }
 
-impl Message<AudioInputSamples> for MicrophoneFeed {
+impl Message<MicrophoneSamples> for MicrophoneFeed {
     type Reply = ();
 
     async fn handle(
         &mut self,
-        msg: AudioInputSamples,
+        msg: MicrophoneSamples,
         _: &mut Context<Self, Self::Reply>,
     ) -> Self::Reply {
         let mut to_remove = vec![];
@@ -223,3 +238,52 @@ impl Message<AudioInputSamples> for MicrophoneFeed {
         }
     }
 }
+
+pub struct Lock;
+
+#[derive(Clone, Debug, thiserror::Error)]
+pub enum LockFeedError {
+    #[error("NoInput")]
+    NoInput,
+}
+
+impl Message<Lock> for MicrophoneFeed {
+    type Reply = Result<MicrophoneFeedLock, LockFeedError>;
+
+    async fn handle(&mut self, _: Lock, ctx: &mut Context<Self, Self::Reply>) -> Self::Reply {
+        let Some((config, _)) = &self.state else {
+            return Err(LockFeedError::NoInput);
+        };
+
+        Ok(MicrophoneFeedLock {
+            config: config.clone(),
+            actor: ctx.actor_ref(),
+            audio_info: AudioInfo::from_stream_config(config),
+        })
+    }
+}
+
+#[derive(Reply)]
+pub struct MicrophoneFeedLock {
+    actor: ActorRef<MicrophoneFeed>,
+    config: SupportedStreamConfig,
+    audio_info: AudioInfo,
+}
+
+impl MicrophoneFeedLock {
+    pub fn config(&self) -> &SupportedStreamConfig {
+        &self.config
+    }
+
+    pub fn audio_info(&self) -> &AudioInfo {
+        &self.audio_info
+    }
+}
+
+impl Deref for MicrophoneFeedLock {
+    type Target = ActorRef<MicrophoneFeed>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.actor
+    }
+}
diff --git a/crates/media/src/feeds/mod.rs b/crates/media/src/feeds/mod.rs
index 8d3043532a..95f1e95464 100644
--- a/crates/media/src/feeds/mod.rs
+++ b/crates/media/src/feeds/mod.rs
@@ -1,8 +1,6 @@
 mod audio;
-mod audio_input;
 mod camera;
 pub mod microphone;
 
 pub use audio::*;
-pub use audio_input::*;
 pub use camera::*;
diff --git a/crates/media/src/sources/audio_input.rs b/crates/media/src/sources/audio_input.rs
index c26d9bf947..36338e802d 100644
--- a/crates/media/src/sources/audio_input.rs
+++ b/crates/media/src/sources/audio_input.rs
@@ -4,13 +4,13 @@ use cpal::{Device, StreamInstant, SupportedStreamConfig};
 use ffmpeg_sys_next::AV_TIME_BASE_Q;
 use flume::{Receiver, Sender};
 use indexmap::IndexMap;
-use std::time::SystemTime;
+use std::{sync::Arc, time::SystemTime};
 use tracing::{error, info};
 
 use crate::{
     MediaError,
     data::FFAudio,
-    feeds::{AudioInputConnection, AudioInputFeed, AudioInputSamples},
+    feeds::microphone::{self, MicrophoneFeedLock, MicrophoneSamples},
     pipeline::{
         clock::{LocalTimestamp, RealTimeClock},
         control::Control,
@@ -27,7 +27,7 @@ impl LocalTimestamp for StreamInstant {
 }
 
 pub struct AudioInputSource {
-    feed_connection: AudioInputConnection,
+    feed: Arc<MicrophoneFeedLock>,
     audio_info: AudioInfo,
     tx: Sender<(FFAudio, f64)>,
     start_timestamp: Option<(StreamInstant, SystemTime)>,
@@ -35,10 +35,14 @@ pub struct AudioInputSource {
 }
 
 impl AudioInputSource {
-    pub fn init(feed: &AudioInputFeed, tx: Sender<(FFAudio, f64)>, start_time: SystemTime) -> Self {
+    pub fn init(
+        feed: Arc<MicrophoneFeedLock>,
+        tx: Sender<(FFAudio, f64)>,
+        start_time: SystemTime,
+    ) -> Self {
         Self {
-            feed_connection: feed.create_connection(),
-            audio_info: feed.audio_info(),
+            audio_info: AudioInfo::from_stream_config(feed.config()),
+            feed,
             tx,
             start_timestamp: None,
             start_time: start_time
@@ -52,7 +56,7 @@ impl AudioInputSource {
         self.audio_info
     }
 
-    fn process_frame(&mut self, samples: AudioInputSamples) -> Result<(), MediaError> {
+    fn process_frame(&mut self, samples: MicrophoneSamples) -> Result<(), MediaError> {
         let start_timestamp = match self.start_timestamp {
             None => *self
                 .start_timestamp
@@ -89,8 +93,8 @@ impl AudioInputSource {
         Ok(())
     }
 
-    fn pause_and_drain_frames(&mut self, frames_rx: Receiver<AudioInputSamples>) {
-        let frames: Vec<AudioInputSamples> = frames_rx.drain().collect();
+    fn pause_and_drain_frames(&mut self, frames_rx: Receiver<MicrophoneSamples>) {
+        let frames: Vec<MicrophoneSamples> = frames_rx.drain().collect();
 
         for frame in frames {
             if let Err(error) = self.process_frame(frame) {
@@ -112,7 +116,7 @@ impl PipelineSourceTask for AudioInputSource {
     ) -> Result<(), String> {
         info!("Preparing audio input source thread...");
 
-        let mut samples_rx: Option<Receiver<AudioInputSamples>> = None;
+        let mut samples_rx: Option<Receiver<MicrophoneSamples>> = None;
         ready_signal.send(Ok(())).unwrap();
 
         fail!("media::sources::audio_input::run");
@@ -120,7 +124,11 @@ impl PipelineSourceTask for AudioInputSource {
         let res = loop {
             match control_signal.last() {
                 Some(Control::Play) => {
-                    let samples = samples_rx.get_or_insert_with(|| self.feed_connection.attach());
+                    let samples = samples_rx.get_or_insert_with(|| {
+                        let (tx, rx) = flume::bounded(5);
+                        let _ = self.feed.ask(microphone::AddSender(tx)).blocking_send();
+                        rx
+                    });
 
                     match samples.recv() {
                         Ok(samples) => {
diff --git a/crates/recording/src/capture_pipeline.rs b/crates/recording/src/capture_pipeline.rs
index fc7a31f646..253825b854 100644
--- a/crates/recording/src/capture_pipeline.rs
+++ b/crates/recording/src/capture_pipeline.rs
@@ -7,7 +7,7 @@ use std::{
 
 use cap_media::{
     MediaError,
-    feeds::AudioInputFeed,
+    feeds::microphone::MicrophoneFeedLock,
     pipeline::{RealTimeClock, builder::PipelineBuilder},
     sources::{
         AVFrameCapture, AudioInputSource, AudioMixer, ScreenCaptureFormat, ScreenCaptureSource,
@@ -40,7 +40,7 @@ pub trait MakeCapturePipeline: ScreenCaptureFormat + std::fmt::Debug + 'static {
             ScreenCaptureSource<Self>,
             flume::Receiver<(Self::VideoFormat, f64)>,
         ),
-        audio: Option<&AudioInputFeed>,
+        audio: Option<Arc<MicrophoneFeedLock>>,
         system_audio: Option<(Receiver<(ffmpeg::frame::Audio, f64)>, AudioInfo)>,
         output_path: PathBuf,
         pause_flag: Arc<AtomicBool>,
@@ -113,7 +113,7 @@ impl MakeCapturePipeline for cap_media::sources::CMSampleBufferCapture {
             ScreenCaptureSource<Self>,
             flume::Receiver<(Self::VideoFormat, f64)>,
         ),
-        audio: Option<&AudioInputFeed>,
+        audio: Option<Arc<MicrophoneFeedLock>>,
         system_audio: Option<(Receiver<(ffmpeg::frame::Audio, f64)>, AudioInfo)>,
         output_path: PathBuf,
         pause_flag: Arc<AtomicBool>,
@@ -126,7 +126,7 @@ impl MakeCapturePipeline for cap_media::sources::CMSampleBufferCapture {
         }
 
         if let Some(audio) = audio {
-            let sink = audio_mixer.sink(audio.audio_info());
+            let sink = audio_mixer.sink(*audio.audio_info());
             let source = AudioInputSource::init(audio, sink.tx, SystemTime::now());
 
             builder.spawn_source("microphone_capture", source);
@@ -273,7 +273,7 @@ impl MakeCapturePipeline for AVFrameCapture {
             ScreenCaptureSource<Self>,
             flume::Receiver<(Self::VideoFormat, f64)>,
         ),
-        audio: Option<&AudioInputFeed>,
+        audio: Option<Arc<MicrophoneFeedLock>>,
         system_audio: Option<(Receiver<(ffmpeg::frame::Audio, f64)>, AudioInfo)>,
         output_path: PathBuf,
         _pause_flag: Arc<AtomicBool>,
@@ -289,7 +289,7 @@ impl MakeCapturePipeline for AVFrameCapture {
         }
 
         if let Some(audio) = audio {
-            let sink = audio_mixer.sink(audio.audio_info());
+            let sink = audio_mixer.sink(*audio.audio_info());
             let source = AudioInputSource::init(audio, sink.tx, SystemTime::now());
 
             builder.spawn_source("microphone_capture", source);
diff --git a/crates/recording/src/instant_recording.rs b/crates/recording/src/instant_recording.rs
index eb90c59a9e..98db761381 100644
--- a/crates/recording/src/instant_recording.rs
+++ b/crates/recording/src/instant_recording.rs
@@ -6,15 +6,16 @@ use std::{
 
 use cap_media::{
     MediaError,
-    feeds::AudioInputFeed,
+    feeds::microphone::{self, MicrophoneFeed, MicrophoneFeedLock},
     pipeline::{Pipeline, RealTimeClock},
     platform::Bounds,
     sources::{ScreenCaptureSource, ScreenCaptureTarget},
 };
-use cap_media_info::VideoInfo;
+use cap_media_info::{AudioInfo, VideoInfo};
 use cap_project::InstantRecordingMeta;
 use cap_utils::{ensure_dir, spawn_actor};
 use flume::Receiver;
+use kameo::actor::ActorRef;
 use tokio::sync::oneshot;
 use tracing::{Instrument, debug, error, info, trace};
 
@@ -118,7 +119,7 @@ async fn create_pipeline<TCaptureFormat: MakeCapturePipeline>(
         ScreenCaptureSource<TCaptureFormat>,
         flume::Receiver<(TCaptureFormat::VideoFormat, f64)>,
     ),
-    audio_input_feed: Option<&AudioInputFeed>,
+    mic_feed: Option<Arc<MicrophoneFeedLock>>,
     system_audio: Option<Receiver<(ffmpeg::frame::Audio, f64)>>,
 ) -> Result<
     (
@@ -127,6 +128,13 @@ async fn create_pipeline<TCaptureFormat: MakeCapturePipeline>(
     ),
     MediaError,
 > {
+    if let Some(mic_feed) = &mic_feed {
+        debug!(
+            "mic audio info: {:#?}",
+            AudioInfo::from_stream_config(mic_feed.config())
+        );
+    };
+
     let clock = RealTimeClock::<()>::new();
     let pipeline_builder = Pipeline::builder(clock);
 
@@ -135,7 +143,7 @@ async fn create_pipeline<TCaptureFormat: MakeCapturePipeline>(
     let pipeline_builder = TCaptureFormat::make_instant_mode_pipeline(
         pipeline_builder,
         screen_source,
-        audio_input_feed,
+        mic_feed,
         system_audio,
         output_path.clone(),
         pause_flag.clone(),
@@ -156,10 +164,10 @@ async fn create_pipeline<TCaptureFormat: MakeCapturePipeline>(
     ))
 }
 
-pub async fn spawn_instant_recording_actor<'a>(
+pub async fn spawn_instant_recording_actor(
     id: String,
     recording_dir: PathBuf,
-    inputs: RecordingBaseInputs<'a>,
+    inputs: RecordingBaseInputs,
 ) -> Result<
     (
         InstantRecordingHandle,
@@ -196,14 +204,10 @@ pub async fn spawn_instant_recording_actor<'a>(
 
     debug!("screen capture: {screen_source:#?}");
 
-    if let Some(audio_feed) = inputs.mic_feed {
-        debug!("mic audio info: {:#?}", audio_feed.audio_info())
-    }
-
     let (pipeline, pipeline_done_rx) = create_pipeline(
         content_dir.join("output.mp4"),
         (screen_source.clone(), screen_rx.clone()),
-        inputs.mic_feed.as_ref(),
+        inputs.mic_feed.clone(),
         system_audio.1,
     )
     .await?;
diff --git a/crates/recording/src/lib.rs b/crates/recording/src/lib.rs
index 6524b2f6a9..31f7c906e5 100644
--- a/crates/recording/src/lib.rs
+++ b/crates/recording/src/lib.rs
@@ -9,12 +9,13 @@ pub use studio_recording::{
 
 use cap_media::{
     MediaError,
-    feeds::{AudioInputFeed, microphone::MicrophoneFeed},
+    feeds::microphone::{MicrophoneFeed, MicrophoneFeedLock},
     platform::Bounds,
     sources::*,
 };
 use kameo::actor::ActorRef;
 use serde::{Deserialize, Serialize};
+use std::sync::Arc;
 use thiserror::Error;
 
 #[derive(specta::Type, Serialize, Deserialize, Clone, Debug, Copy)]
@@ -37,10 +38,10 @@ pub struct RecordingOptions {
 }
 
 #[derive(Clone)]
-pub struct RecordingBaseInputs<'a> {
+pub struct RecordingBaseInputs {
     pub capture_target: ScreenCaptureTarget,
     pub capture_system_audio: bool,
-    pub mic_feed: &'a Option<ActorRef<MicrophoneFeed>>,
+    pub mic_feed: Option<Arc<MicrophoneFeedLock>>,
 }
 
 #[derive(specta::Type, Serialize, Deserialize, Clone, Debug)]
diff --git a/crates/recording/src/studio_recording.rs b/crates/recording/src/studio_recording.rs
index 149d8bba05..c8ad2c7906 100644
--- a/crates/recording/src/studio_recording.rs
+++ b/crates/recording/src/studio_recording.rs
@@ -7,7 +7,10 @@ use std::{
 
 use cap_media::{
     MediaError,
-    feeds::{AudioInputFeed, CameraFeed},
+    feeds::{
+        CameraFeed,
+        microphone::{self, MicrophoneFeed, MicrophoneFeedLock},
+    },
     pipeline::{Pipeline, RealTimeClock},
     platform::Bounds,
     sources::{AudioInputSource, CameraSource, ScreenCaptureFormat, ScreenCaptureTarget},
@@ -17,6 +20,7 @@ use cap_media_info::VideoInfo;
 use cap_project::{CursorEvents, StudioRecordingMeta};
 use cap_utils::spawn_actor;
 use flume::Receiver;
+use kameo::actor::ActorRef;
 use relative_path::RelativePathBuf;
 use tokio::sync::{Mutex, oneshot};
 use tracing::{debug, info, trace};
@@ -126,10 +130,10 @@ impl StudioRecordingHandle {
     }
 }
 
-pub async fn spawn_studio_recording_actor<'a>(
+pub async fn spawn_studio_recording_actor(
     id: String,
     recording_dir: PathBuf,
-    base_inputs: RecordingBaseInputs<'a>,
+    base_inputs: RecordingBaseInputs,
     camera_feed: Option<Arc<Mutex<CameraFeed>>>,
     custom_cursor_capture: bool,
 ) -> Result<(StudioRecordingHandle, oneshot::Receiver<Result<(), String>>), RecordingError> {
@@ -156,16 +160,15 @@ pub async fn spawn_studio_recording_actor<'a>(
         debug!("camera video info: {:#?}", camera_feed.video_info());
     }
 
-    if let Some(audio_feed) = base_inputs.mic_feed {
-        debug!("mic audio info: {:#?}", audio_feed.audio_info())
-    }
-    let audio_input_feed = base_inputs.mic_feed.clone();
+    if let Some(mic_feed) = &base_inputs.mic_feed {
+        debug!("mic audio info: {:#?}", mic_feed.audio_info());
+    };
 
     let mut segment_pipeline_factory = SegmentPipelineFactory::new(
         segments_dir,
         cursors_dir,
         base_inputs.capture_target,
-        audio_input_feed,
+        base_inputs.mic_feed.clone(),
         base_inputs.capture_system_audio,
         camera_feed,
         custom_cursor_capture,
@@ -561,7 +564,7 @@ struct SegmentPipelineFactory {
     segments_dir: PathBuf,
     cursors_dir: PathBuf,
     capture_target: ScreenCaptureTarget,
-    audio_input_feed: Option<AudioInputFeed>,
+    mic_feed: Option<Arc<MicrophoneFeedLock>>,
     capture_system_audio: bool,
     camera_feed: Option<Arc<Mutex<CameraFeed>>>,
     custom_cursor_capture: bool,
@@ -576,7 +579,7 @@ impl SegmentPipelineFactory {
         segments_dir: PathBuf,
         cursors_dir: PathBuf,
         capture_target: ScreenCaptureTarget,
-        audio_input_feed: Option<AudioInputFeed>,
+        mic_feed: Option<Arc<MicrophoneFeedLock>>,
         capture_system_audio: bool,
         camera_feed: Option<Arc<Mutex<CameraFeed>>>,
         custom_cursor_capture: bool,
@@ -587,7 +590,7 @@ impl SegmentPipelineFactory {
             segments_dir,
             cursors_dir,
             capture_target,
-            audio_input_feed,
+            mic_feed,
             capture_system_audio,
             camera_feed,
             custom_cursor_capture,
@@ -613,7 +616,7 @@ impl SegmentPipelineFactory {
             &self.cursors_dir,
             self.index,
             self.capture_target,
-            &self.audio_input_feed,
+            self.mic_feed.clone(),
             self.capture_system_audio,
             self.camera_feed.as_deref(),
             cursors,
@@ -637,7 +640,7 @@ async fn create_segment_pipeline(
     cursors_dir: &Path,
     index: u32,
     capture_target: ScreenCaptureTarget,
-    mic_feed: &Option<AudioInputFeed>,
+    mic_feed: Option<Arc<MicrophoneFeedLock>>,
     capture_system_audio: bool,
     camera_feed: Option<&Mutex<CameraFeed>>,
     prev_cursors: Cursors,
@@ -716,10 +719,10 @@ async fn create_segment_pipeline(
         }
     };
 
-    let microphone = if let Some(mic_source) = mic_feed {
+    let microphone = if let Some(mic_feed) = mic_feed {
         let (tx, rx) = flume::bounded(8);
 
-        let mic_source = AudioInputSource::init(mic_source, tx, start_time);
+        let mic_source = AudioInputSource::init(mic_feed, tx, start_time);
 
         let mic_config = mic_source.info();
         let output_path = dir.join("audio-input.ogg");
diff --git a/crates/scap-direct3d/examples/cli.rs b/crates/scap-direct3d/examples/cli.rs
index d7ad710afe..fe3bf94cc2 100644
--- a/crates/scap-direct3d/examples/cli.rs
+++ b/crates/scap-direct3d/examples/cli.rs
@@ -1,27 +1,35 @@
-use scap_direct3d::{Capturer, Display, PixelFormat, Settings};
-use std::time::Duration;
-
 fn main() {
-    let display = Display::primary().unwrap();
+    #[cfg(windows)]
+    win::main();
+}
+
+#[cfg(windows)]
+mod win {
+    use scap_direct3d::{Capturer, Display, PixelFormat, Settings};
+    use std::time::Duration;
+
+    pub fn main() {
+        let display = Display::primary().unwrap();
 
-    let capturer = Capturer::new(
-        display.try_as_capture_item().unwrap(),
-        Settings {
-            is_border_required: Some(true),
-            is_cursor_capture_enabled: Some(true),
-            pixel_format: PixelFormat::R8G8B8A8Unorm,
-        },
-    );
+        let capturer = Capturer::new(
+            display.try_as_capture_item().unwrap(),
+            Settings {
+                is_border_required: Some(true),
+                is_cursor_capture_enabled: Some(true),
+                pixel_format: PixelFormat::R8G8B8A8Unorm,
+            },
+        );
 
-    let capture_handle = capturer.start(|frame| {
-        dbg!(frame);
+        let capture_handle = capturer.start(|frame| {
+            dbg!(frame);
 
-        Ok(())
-    });
+            Ok(())
+        });
 
-    std::thread::sleep(Duration::from_secs(3));
+        std::thread::sleep(Duration::from_secs(3));
 
-    capture_handle.stop().unwrap();
+        capture_handle.stop().unwrap();
 
-    std::thread::sleep(Duration::from_secs(3));
+        std::thread::sleep(Duration::from_secs(3));
+    }
 }
diff --git a/packages/ui-solid/src/auto-imports.d.ts b/packages/ui-solid/src/auto-imports.d.ts
index 054b44f3c1..844138e5ca 100644
--- a/packages/ui-solid/src/auto-imports.d.ts
+++ b/packages/ui-solid/src/auto-imports.d.ts
@@ -3,6 +3,7 @@
 // @ts-nocheck
 // noinspection JSUnusedGlobalSymbols
 // Generated by unplugin-auto-import
+// biome-ignore lint: disable
 export {};
 declare global {
 	const IconCapArrows: typeof import("~icons/cap/arrows.jsx")["default"];

From 825b99c094db8dfc471824079d1401794adb87bf Mon Sep 17 00:00:00 2001
From: Brendan Allan <brendonovich@outlook.com>
Date: Mon, 25 Aug 2025 16:16:13 +0800
Subject: [PATCH 3/7] manage connect and error events properly

---
 apps/desktop/src-tauri/src/lib.rs         |  22 ---
 crates/media/src/feeds/microphone.rs      | 207 +++++++++++++++++-----
 crates/recording/src/instant_recording.rs |   3 +-
 crates/recording/src/lib.rs               |   8 +-
 crates/recording/src/studio_recording.rs  |   6 +-
 5 files changed, 162 insertions(+), 84 deletions(-)

diff --git a/apps/desktop/src-tauri/src/lib.rs b/apps/desktop/src-tauri/src/lib.rs
index d7de2a8e3e..11f4203f4f 100644
--- a/apps/desktop/src-tauri/src/lib.rs
+++ b/apps/desktop/src-tauri/src/lib.rs
@@ -2422,28 +2422,6 @@ trait EventExt: tauri_specta::Event {
 
 impl<T: tauri_specta::Event> EventExt for T {}
 
-trait TransposeAsync {
-    type Output;
-
-    fn transpose_async(self) -> impl Future<Output = Self::Output>
-    where
-        Self: Sized;
-}
-
-impl<F: Future<Output = T>, T, E> TransposeAsync for Result<F, E> {
-    type Output = Result<T, E>;
-
-    async fn transpose_async(self) -> Self::Output
-    where
-        Self: Sized,
-    {
-        match self {
-            Ok(f) => Ok(f.await),
-            Err(e) => Err(e),
-        }
-    }
-}
-
 fn open_project_from_path(path: &Path, app: AppHandle) -> Result<(), String> {
     let meta = RecordingMeta::load_for_project(path).map_err(|v| v.to_string())?;
 
diff --git a/crates/media/src/feeds/microphone.rs b/crates/media/src/feeds/microphone.rs
index 2a4f6a5697..8f44b8917a 100644
--- a/crates/media/src/feeds/microphone.rs
+++ b/crates/media/src/feeds/microphone.rs
@@ -1,13 +1,15 @@
-use std::{ops::Deref, sync::mpsc};
+use std::{
+    ops::Deref,
+    sync::mpsc::{self, SyncSender},
+};
 
 use cap_media_info::{AudioInfo, ffmpeg_sample_format_for};
 use cpal::{
-    BuildStreamError, Device, InputCallbackInfo, PlayStreamError, SampleFormat, StreamConfig,
-    StreamError, SupportedStreamConfig,
+    Device, InputCallbackInfo, SampleFormat, StreamError, SupportedStreamConfig,
     traits::{DeviceTrait, HostTrait, StreamTrait},
 };
 use flume::TrySendError;
-use futures::channel::oneshot;
+use futures::{FutureExt, channel::oneshot, future::BoxFuture};
 use indexmap::IndexMap;
 use kameo::prelude::*;
 use tracing::{debug, error, info, trace, warn};
@@ -23,15 +25,30 @@ pub struct MicrophoneSamples {
 
 #[derive(Actor)]
 pub struct MicrophoneFeed {
-    state: Option<(SupportedStreamConfig, mpsc::SyncSender<()>)>,
+    input_id_counter: u32,
+    state: State,
     senders: Vec<flume::Sender<MicrophoneSamples>>,
     error_sender: flume::Sender<StreamError>,
 }
 
+enum State {
+    Detached,
+    Initializing {
+        id: u32,
+        ready: BoxFuture<'static, Result<SupportedStreamConfig, SetInputError>>,
+    },
+    Attached {
+        id: u32,
+        config: SupportedStreamConfig,
+        done_tx: mpsc::SyncSender<()>,
+    },
+}
+
 impl MicrophoneFeed {
     pub fn new(error_sender: flume::Sender<StreamError>) -> Self {
         Self {
-            state: None,
+            input_id_counter: 0,
+            state: State::Detached,
             senders: Vec::new(),
             error_sender,
         }
@@ -98,27 +115,78 @@ impl MicrophoneFeed {
     }
 }
 
+#[derive(Reply)]
+pub struct MicrophoneFeedLock {
+    actor: ActorRef<MicrophoneFeed>,
+    config: SupportedStreamConfig,
+    audio_info: AudioInfo,
+}
+
+impl MicrophoneFeedLock {
+    pub fn config(&self) -> &SupportedStreamConfig {
+        &self.config
+    }
+
+    pub fn audio_info(&self) -> &AudioInfo {
+        &self.audio_info
+    }
+}
+
+impl Deref for MicrophoneFeedLock {
+    type Target = ActorRef<MicrophoneFeed>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.actor
+    }
+}
+
+// Public Requests
+
 pub struct SetInput {
     pub label: String,
 }
 
-#[derive(Debug, thiserror::Error)]
+pub struct RemoveInput;
+
+pub struct AddSender(pub flume::Sender<MicrophoneSamples>);
+
+pub struct Lock;
+
+// Private Events
+
+struct InputConnected {
+    id: u32,
+    config: SupportedStreamConfig,
+    done_tx: SyncSender<()>,
+}
+struct InputConnectFailed {
+    id: u32,
+}
+
+// Impls
+
+#[derive(Clone, Debug, thiserror::Error)]
 pub enum SetInputError {
     #[error("DeviceNotFound")]
     DeviceNotFound,
     #[error("BuildStreamCrashed")]
     BuildStreamCrashed,
+    // we use stringes for these as the cpal errors aren't Clone
     #[error("BuildStream: {0}")]
-    BuildStream(BuildStreamError),
+    BuildStream(String),
     #[error("PlayStream: {0}")]
-    PlayStream(PlayStreamError),
+    PlayStream(String),
 }
 
 impl Message<SetInput> for MicrophoneFeed {
-    type Reply = Result<SupportedStreamConfig, SetInputError>;
+    type Reply =
+        Result<BoxFuture<'static, Result<SupportedStreamConfig, SetInputError>>, SetInputError>;
 
     async fn handle(&mut self, msg: SetInput, ctx: &mut Context<Self, Self::Reply>) -> Self::Reply {
-        trace!("MicrophoneFeed.SetInput('{:?}')", &msg.label);
+        trace!("MicrophoneFeed.SetInput('{}')", &msg.label);
+
+        let id = self.input_id_counter;
+        self.input_id_counter += 1;
 
         let Some((device, config)) = Self::list().swap_remove(&msg.label) else {
             return Err(SetInputError::DeviceNotFound);
@@ -131,8 +199,19 @@ impl Message<SetInput> for MicrophoneFeed {
 
         let _stream_config = config.clone().into();
         let actor_ref = ctx.actor_ref();
+        let ready = ready_rx
+            .map(|v| {
+                v.map_err(|_| SetInputError::BuildStreamCrashed)
+                    .map(|_| config)
+            })
+            .shared();
         let error_sender = self.error_sender.clone();
 
+        self.state = State::Initializing {
+            id,
+            ready: ready.clone().boxed(),
+        };
+
         std::thread::spawn(move || {
             let stream = match device.build_input_stream_raw(
                 &_stream_config,
@@ -159,13 +238,13 @@ impl Message<SetInput> for MicrophoneFeed {
             ) {
                 Ok(stream) => stream,
                 Err(e) => {
-                    let _ = ready_tx.send(Err(SetInputError::BuildStream(e)));
+                    let _ = ready_tx.send(Err(SetInputError::BuildStream(e.to_string())));
                     return;
                 }
             };
 
             if let Err(e) = stream.play() {
-                let _ = ready_tx.send(Err(SetInputError::PlayStream(e)));
+                let _ = ready_tx.send(Err(SetInputError::PlayStream(e.to_string())));
                 return;
             }
 
@@ -181,30 +260,47 @@ impl Message<SetInput> for MicrophoneFeed {
             }
         });
 
-        ready_rx
-            .await
-            .map_err(|_| SetInputError::BuildStreamCrashed)??;
-
-        self.state = Some((config.clone(), done_tx));
+        tokio::spawn({
+            let ready = ready.clone();
+            let actor = ctx.actor_ref();
+            async move {
+                match ready.await {
+                    Ok(config) => {
+                        let _ = actor
+                            .tell(InputConnected {
+                                id,
+                                config,
+                                done_tx,
+                            })
+                            .await;
+                    }
+                    Err(_) => {
+                        let _ = actor.tell(InputConnectFailed { id }).await;
+                    }
+                }
+            }
+        });
 
-        Ok(config)
+        Ok(ready.boxed())
     }
 }
 
-pub struct RemoveInput;
-
 impl Message<RemoveInput> for MicrophoneFeed {
     type Reply = ();
 
     async fn handle(&mut self, _: RemoveInput, _: &mut Context<Self, Self::Reply>) -> Self::Reply {
-        if let Some((_, done_tx)) = self.state.take() {
-            let _ = done_tx.send(());
+        trace!("MicrophoneFeed.RemoveInput");
+
+        match std::mem::replace(&mut self.state, State::Detached) {
+            State::Detached => {}
+            State::Initializing { .. } => {}
+            State::Attached { done_tx, .. } => {
+                let _ = done_tx.send(());
+            }
         }
     }
 }
 
-pub struct AddSender(pub flume::Sender<MicrophoneSamples>);
-
 impl Message<AddSender> for MicrophoneFeed {
     type Reply = ();
 
@@ -239,51 +335,66 @@ impl Message<MicrophoneSamples> for MicrophoneFeed {
     }
 }
 
-pub struct Lock;
-
 #[derive(Clone, Debug, thiserror::Error)]
 pub enum LockFeedError {
     #[error("NoInput")]
     NoInput,
+    #[error("InitializeFailed${0}")]
+    InitializeFailed(SetInputError),
 }
 
 impl Message<Lock> for MicrophoneFeed {
     type Reply = Result<MicrophoneFeedLock, LockFeedError>;
 
     async fn handle(&mut self, _: Lock, ctx: &mut Context<Self, Self::Reply>) -> Self::Reply {
-        let Some((config, _)) = &self.state else {
-            return Err(LockFeedError::NoInput);
+        let config = match &mut self.state {
+            State::Detached => return Err(LockFeedError::NoInput),
+            State::Initializing { ready, .. } => {
+                ready.await.map_err(LockFeedError::InitializeFailed)?
+            }
+            State::Attached { config, .. } => config.clone(),
         };
 
         Ok(MicrophoneFeedLock {
-            config: config.clone(),
+            audio_info: AudioInfo::from_stream_config(&config),
             actor: ctx.actor_ref(),
-            audio_info: AudioInfo::from_stream_config(config),
+            config,
         })
     }
 }
 
-#[derive(Reply)]
-pub struct MicrophoneFeedLock {
-    actor: ActorRef<MicrophoneFeed>,
-    config: SupportedStreamConfig,
-    audio_info: AudioInfo,
-}
-
-impl MicrophoneFeedLock {
-    pub fn config(&self) -> &SupportedStreamConfig {
-        &self.config
-    }
+impl Message<InputConnected> for MicrophoneFeed {
+    type Reply = ();
 
-    pub fn audio_info(&self) -> &AudioInfo {
-        &self.audio_info
+    async fn handle(
+        &mut self,
+        msg: InputConnected,
+        _: &mut Context<Self, Self::Reply>,
+    ) -> Self::Reply {
+        if let State::Initializing { id, .. } = self.state
+            && id == msg.id
+        {
+            self.state = State::Attached {
+                id: msg.id,
+                config: msg.config,
+                done_tx: msg.done_tx,
+            };
+        }
     }
 }
 
-impl Deref for MicrophoneFeedLock {
-    type Target = ActorRef<MicrophoneFeed>;
+impl Message<InputConnectFailed> for MicrophoneFeed {
+    type Reply = ();
 
-    fn deref(&self) -> &Self::Target {
-        &self.actor
+    async fn handle(
+        &mut self,
+        msg: InputConnectFailed,
+        _: &mut Context<Self, Self::Reply>,
+    ) -> Self::Reply {
+        if let State::Attached { id, .. } = self.state
+            && id == msg.id
+        {
+            self.state = State::Detached;
+        }
     }
 }
diff --git a/crates/recording/src/instant_recording.rs b/crates/recording/src/instant_recording.rs
index 98db761381..565a530f61 100644
--- a/crates/recording/src/instant_recording.rs
+++ b/crates/recording/src/instant_recording.rs
@@ -6,7 +6,7 @@ use std::{
 
 use cap_media::{
     MediaError,
-    feeds::microphone::{self, MicrophoneFeed, MicrophoneFeedLock},
+    feeds::microphone::MicrophoneFeedLock,
     pipeline::{Pipeline, RealTimeClock},
     platform::Bounds,
     sources::{ScreenCaptureSource, ScreenCaptureTarget},
@@ -15,7 +15,6 @@ use cap_media_info::{AudioInfo, VideoInfo};
 use cap_project::InstantRecordingMeta;
 use cap_utils::{ensure_dir, spawn_actor};
 use flume::Receiver;
-use kameo::actor::ActorRef;
 use tokio::sync::oneshot;
 use tracing::{Instrument, debug, error, info, trace};
 
diff --git a/crates/recording/src/lib.rs b/crates/recording/src/lib.rs
index 31f7c906e5..4dbe24230a 100644
--- a/crates/recording/src/lib.rs
+++ b/crates/recording/src/lib.rs
@@ -7,13 +7,7 @@ pub use studio_recording::{
     CompletedStudioRecording, StudioRecordingHandle, spawn_studio_recording_actor,
 };
 
-use cap_media::{
-    MediaError,
-    feeds::microphone::{MicrophoneFeed, MicrophoneFeedLock},
-    platform::Bounds,
-    sources::*,
-};
-use kameo::actor::ActorRef;
+use cap_media::{MediaError, feeds::microphone::MicrophoneFeedLock, platform::Bounds, sources::*};
 use serde::{Deserialize, Serialize};
 use std::sync::Arc;
 use thiserror::Error;
diff --git a/crates/recording/src/studio_recording.rs b/crates/recording/src/studio_recording.rs
index c8ad2c7906..81838900b8 100644
--- a/crates/recording/src/studio_recording.rs
+++ b/crates/recording/src/studio_recording.rs
@@ -7,10 +7,7 @@ use std::{
 
 use cap_media::{
     MediaError,
-    feeds::{
-        CameraFeed,
-        microphone::{self, MicrophoneFeed, MicrophoneFeedLock},
-    },
+    feeds::{CameraFeed, microphone::MicrophoneFeedLock},
     pipeline::{Pipeline, RealTimeClock},
     platform::Bounds,
     sources::{AudioInputSource, CameraSource, ScreenCaptureFormat, ScreenCaptureTarget},
@@ -20,7 +17,6 @@ use cap_media_info::VideoInfo;
 use cap_project::{CursorEvents, StudioRecordingMeta};
 use cap_utils::spawn_actor;
 use flume::Receiver;
-use kameo::actor::ActorRef;
 use relative_path::RelativePathBuf;
 use tokio::sync::{Mutex, oneshot};
 use tracing::{debug, info, trace};

From 905fd5f3b9878c5abc51cdd20a5b5cf15569114c Mon Sep 17 00:00:00 2001
From: Brendan Allan <brendonovich@outlook.com>
Date: Mon, 25 Aug 2025 18:31:39 +0800
Subject: [PATCH 4/7] restructure to be async

---
 Cargo.lock                                    |  13 +-
 .../src/routes/(window-chrome)/(main).tsx     |  12 +-
 apps/desktop/src/utils/queries.ts             |  45 +--
 crates/recording/Cargo.toml                   |   1 +
 crates/recording/src/feeds/microphone.rs      | 300 ++++++++++++------
 packages/ui-solid/src/auto-imports.d.ts       |  88 ++---
 6 files changed, 288 insertions(+), 171 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index a1d823f700..a0fad2ad34 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1285,6 +1285,7 @@ dependencies = [
  "objc",
  "objc2-app-kit",
  "relative-path",
+ "replace_with",
  "ringbuf",
  "scap-cpal",
  "scap-direct3d",
@@ -3783,7 +3784,7 @@ dependencies = [
  "js-sys",
  "log",
  "wasm-bindgen",
- "windows-core 0.58.0",
+ "windows-core 0.61.2",
 ]
 
 [[package]]
@@ -4445,7 +4446,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "07033963ba89ebaf1584d767badaa2e8fcec21aedea6b8c0346d487d49c28667"
 dependencies = [
  "cfg-if",
- "windows-targets 0.48.5",
+ "windows-targets 0.53.3",
 ]
 
 [[package]]
@@ -6643,6 +6644,12 @@ version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "19b30a45b0cd0bcca8037f3d0dc3421eaf95327a17cad11964fb8179b4fc4832"
 
+[[package]]
+name = "replace_with"
+version = "0.1.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "51743d3e274e2b18df81c4dc6caf8a5b8e15dbe799e0dca05c7617380094e884"
+
 [[package]]
 name = "reqwest"
 version = "0.12.22"
@@ -10156,7 +10163,7 @@ version = "0.1.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "cf221c93e13a30d793f7645a0e7762c55d169dbb0a49671918a2319d289b10bb"
 dependencies = [
- "windows-sys 0.48.0",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
diff --git a/apps/desktop/src/routes/(window-chrome)/(main).tsx b/apps/desktop/src/routes/(window-chrome)/(main).tsx
index f55f702fa3..f250974dfe 100644
--- a/apps/desktop/src/routes/(window-chrome)/(main).tsx
+++ b/apps/desktop/src/routes/(window-chrome)/(main).tsx
@@ -253,7 +253,8 @@ function Page() {
 	const setCamera = createCameraMutation();
 
 	onMount(() => {
-		if (rawOptions.cameraID) setCamera.mutate(rawOptions.cameraID);
+		if (rawOptions.micName) commands.setMicInput(rawOptions.micName);
+		if (rawOptions.cameraID) setCamera.rawMutate(rawOptions.cameraID);
 	});
 
 	return (
@@ -817,7 +818,6 @@ function MicrophoneSelect(props: {
 	const currentRecording = createCurrentRecordingQuery();
 
 	const [dbs, setDbs] = createSignal<number | undefined>();
-	const [isInitialized, setIsInitialized] = createSignal(false);
 
 	const requestPermission = useRequestPermission();
 
@@ -848,14 +848,6 @@ function MicrophoneSelect(props: {
 	const audioLevel = () =>
 		(1 - Math.max((dbs() ?? 0) + DB_SCALE, 0) / DB_SCALE) ** 0.5;
 
-	// Initialize audio input if needed - only once when component mounts
-	onMount(() => {
-		if (!props.value || !permissionGranted() || isInitialized()) return;
-
-		setIsInitialized(true);
-		handleMicrophoneChange({ name: props.value });
-	});
-
 	return (
 		<div class="flex flex-col gap-[0.25rem] items-stretch text-[--text-primary]">
 			<button
diff --git a/apps/desktop/src/utils/queries.ts b/apps/desktop/src/utils/queries.ts
index 2e0fa67f19..0d85c86783 100644
--- a/apps/desktop/src/utils/queries.ts
+++ b/apps/desktop/src/utils/queries.ts
@@ -1,9 +1,9 @@
 import { createEventListener } from "@solid-primitives/event-listener";
 import { makePersisted } from "@solid-primitives/storage";
 import {
-	createMutation,
 	createQuery,
 	queryOptions,
+	useMutation,
 	useQuery,
 } from "@tanstack/solid-query";
 import { getCurrentWindow } from "@tauri-apps/api/window";
@@ -152,26 +152,33 @@ export function createLicenseQuery() {
 export function createCameraMutation() {
 	const { setOptions, rawOptions } = useRecordingOptions();
 
-	const setCameraInput = createMutation(() => ({
-		mutationFn: async (model: DeviceOrModelID | null) => {
-			const before = rawOptions.cameraID ? { ...rawOptions.cameraID } : null;
-			setOptions("cameraID", reconcile(model));
-			if (model) {
-				await commands.showWindow("Camera");
-				getCurrentWindow().setFocus();
-			}
-
-			await commands.setCameraInput(model).catch(async (e) => {
-				if (JSON.stringify(before) === JSON.stringify(model) || !before) {
-					setOptions("cameraID", null);
-				} else setOptions("cameraID", reconcile(before));
-
-				throw e;
-			});
-		},
+	const rawMutate = async (model: DeviceOrModelID | null) => {
+		const before = rawOptions.cameraID ? { ...rawOptions.cameraID } : null;
+		setOptions("cameraID", reconcile(model));
+		if (model) {
+			await commands.showWindow("Camera");
+			getCurrentWindow().setFocus();
+		}
+
+		await commands.setCameraInput(model).catch(async (e) => {
+			if (JSON.stringify(before) === JSON.stringify(model) || !before) {
+				setOptions("cameraID", null);
+			} else setOptions("cameraID", reconcile(before));
+
+			throw e;
+		});
+	};
+
+	const setCameraInput = useMutation(() => ({
+		mutationFn: rawMutate,
 	}));
 
-	return setCameraInput;
+	return new Proxy(setCameraInput as typeof setCameraInput & { rawMutate: typeof rawMutate }, {
+		get(target, key) {
+			if (key === 'rawMutate') return rawMutate;
+			return Reflect.get(target, key);
+		}
+	});
 }
 
 export function createCustomDomainQuery() {
diff --git a/crates/recording/Cargo.toml b/crates/recording/Cargo.toml
index 25b5cf7e1f..6ac1308461 100644
--- a/crates/recording/Cargo.toml
+++ b/crates/recording/Cargo.toml
@@ -45,6 +45,7 @@ cpal.workspace = true
 indexmap = "2.10.0"
 kameo = "0.17.2"
 inquire = "0.7.5"
+replace_with = "0.1.8"
 
 [target.'cfg(target_os = "macos")'.dependencies]
 screencapturekit = "0.3.5"
diff --git a/crates/recording/src/feeds/microphone.rs b/crates/recording/src/feeds/microphone.rs
index 8f44b8917a..07f20ceec8 100644
--- a/crates/recording/src/feeds/microphone.rs
+++ b/crates/recording/src/feeds/microphone.rs
@@ -1,8 +1,3 @@
-use std::{
-    ops::Deref,
-    sync::mpsc::{self, SyncSender},
-};
-
 use cap_media_info::{AudioInfo, ffmpeg_sample_format_for};
 use cpal::{
     Device, InputCallbackInfo, SampleFormat, StreamError, SupportedStreamConfig,
@@ -12,6 +7,11 @@ use flume::TrySendError;
 use futures::{FutureExt, channel::oneshot, future::BoxFuture};
 use indexmap::IndexMap;
 use kameo::prelude::*;
+use replace_with::replace_with_or_abort;
+use std::{
+    ops::Deref,
+    sync::mpsc::{self, SyncSender},
+};
 use tracing::{debug, error, info, trace, warn};
 
 pub type MicrophonesMap = IndexMap<String, (Device, SupportedStreamConfig)>;
@@ -32,23 +32,59 @@ pub struct MicrophoneFeed {
 }
 
 enum State {
-    Detached,
-    Initializing {
-        id: u32,
-        ready: BoxFuture<'static, Result<SupportedStreamConfig, SetInputError>>,
-    },
-    Attached {
-        id: u32,
-        config: SupportedStreamConfig,
-        done_tx: mpsc::SyncSender<()>,
-    },
+    Open(OpenState),
+    Locked { inner: AttachedState },
+}
+
+impl State {
+    fn try_as_open(&mut self) -> Result<&mut OpenState, FeedLockedError> {
+        if let Self::Open(open_state) = self {
+            Ok(open_state)
+        } else {
+            Err(FeedLockedError)
+        }
+    }
+}
+
+struct OpenState {
+    connecting: Option<ConnectingState>,
+    attached: Option<AttachedState>,
+}
+
+impl OpenState {
+    fn handle_input_connected(&mut self, data: InputConnected) {
+        if let Some(connecting) = &self.connecting
+            && data.id == connecting.id
+        {
+            self.attached = Some(AttachedState {
+                id: data.id,
+                config: data.config.clone(),
+                done_tx: data.done_tx,
+            });
+            self.connecting = None;
+        }
+    }
+}
+
+struct ConnectingState {
+    id: u32,
+    ready: BoxFuture<'static, Result<InputConnected, SetInputError>>,
+}
+
+struct AttachedState {
+    id: u32,
+    config: SupportedStreamConfig,
+    done_tx: mpsc::SyncSender<()>,
 }
 
 impl MicrophoneFeed {
     pub fn new(error_sender: flume::Sender<StreamError>) -> Self {
         Self {
             input_id_counter: 0,
-            state: State::Detached,
+            state: State::Open(OpenState {
+                connecting: None,
+                attached: None,
+            }),
             senders: Vec::new(),
             error_sender,
         }
@@ -120,6 +156,7 @@ pub struct MicrophoneFeedLock {
     actor: ActorRef<MicrophoneFeed>,
     config: SupportedStreamConfig,
     audio_info: AudioInfo,
+    lock_tx: Recipient<Unlock>,
 }
 
 impl MicrophoneFeedLock {
@@ -140,6 +177,12 @@ impl Deref for MicrophoneFeedLock {
     }
 }
 
+impl Drop for MicrophoneFeedLock {
+    fn drop(&mut self) {
+        let _ = self.lock_tx.tell(Unlock).blocking_send();
+    }
+}
+
 // Public Requests
 
 pub struct SetInput {
@@ -159,19 +202,28 @@ struct InputConnected {
     config: SupportedStreamConfig,
     done_tx: SyncSender<()>,
 }
+
 struct InputConnectFailed {
     id: u32,
 }
 
+struct Unlock;
+
 // Impls
 
+#[derive(Debug, Clone, Copy, thiserror::Error)]
+#[error("FeedLocked")]
+pub struct FeedLockedError;
+
 #[derive(Clone, Debug, thiserror::Error)]
 pub enum SetInputError {
+    #[error(transparent)]
+    Locked(#[from] FeedLockedError),
     #[error("DeviceNotFound")]
     DeviceNotFound,
     #[error("BuildStreamCrashed")]
     BuildStreamCrashed,
-    // we use stringes for these as the cpal errors aren't Clone
+    // we use strings for these as the cpal errors aren't Clone
     #[error("BuildStream: {0}")]
     BuildStream(String),
     #[error("PlayStream: {0}")]
@@ -185,6 +237,8 @@ impl Message<SetInput> for MicrophoneFeed {
     async fn handle(&mut self, msg: SetInput, ctx: &mut Context<Self, Self::Reply>) -> Self::Reply {
         trace!("MicrophoneFeed.SetInput('{}')", &msg.label);
 
+        let state = self.state.try_as_open()?;
+
         let id = self.input_id_counter;
         self.input_id_counter += 1;
 
@@ -197,65 +251,82 @@ impl Message<SetInput> for MicrophoneFeed {
         let (ready_tx, ready_rx) = oneshot::channel();
         let (done_tx, done_rx) = mpsc::sync_channel(0);
 
-        let _stream_config = config.clone().into();
         let actor_ref = ctx.actor_ref();
-        let ready = ready_rx
-            .map(|v| {
-                v.map_err(|_| SetInputError::BuildStreamCrashed)
-                    .map(|_| config)
-            })
-            .shared();
+        let ready = {
+            let config = config.clone();
+            ready_rx
+                .map(|v| {
+                    v.map_err(|_| SetInputError::BuildStreamCrashed)
+                        .map(|_| config)
+                })
+                .shared()
+        };
         let error_sender = self.error_sender.clone();
 
-        self.state = State::Initializing {
+        state.connecting = Some(ConnectingState {
             id,
-            ready: ready.clone().boxed(),
-        };
+            ready: {
+                let done_tx = done_tx.clone();
+                ready
+                    .clone()
+                    .map(move |v| {
+                        v.map(|config| InputConnected {
+                            id,
+                            config,
+                            done_tx,
+                        })
+                    })
+                    .boxed()
+            },
+        });
 
-        std::thread::spawn(move || {
-            let stream = match device.build_input_stream_raw(
-                &_stream_config,
-                sample_format,
-                {
-                    let actor_ref = actor_ref.clone();
-                    move |data, info| {
-                        let _ = actor_ref
-                            .tell(MicrophoneSamples {
-                                data: data.bytes().to_vec(),
-                                format: data.sample_format(),
-                                info: info.clone(),
-                            })
-                            .try_send();
+        std::thread::spawn({
+            let config = config.clone();
+            move || {
+                let stream = match device.build_input_stream_raw(
+                    &config.into(),
+                    sample_format,
+                    {
+                        let actor_ref = actor_ref.clone();
+                        move |data, info| {
+                            let _ = actor_ref
+                                .tell(MicrophoneSamples {
+                                    data: data.bytes().to_vec(),
+                                    format: data.sample_format(),
+                                    info: info.clone(),
+                                })
+                                .try_send();
+                        }
+                    },
+                    move |e| {
+                        error!("Microphone stream error: {e}");
+
+                        let _ = error_sender.send(e).is_err();
+                        actor_ref.kill();
+                    },
+                    None,
+                ) {
+                    Ok(stream) => stream,
+                    Err(e) => {
+                        let _ = ready_tx.send(Err(SetInputError::BuildStream(e.to_string())));
+                        return;
                     }
-                },
-                move |e| {
-                    error!("Microphone stream error: {e}");
-
-                    let _ = error_sender.send(e).is_err();
-                    actor_ref.kill();
-                },
-                None,
-            ) {
-                Ok(stream) => stream,
-                Err(e) => {
-                    let _ = ready_tx.send(Err(SetInputError::BuildStream(e.to_string())));
+                };
+
+                if let Err(e) = stream.play() {
+                    let _ = ready_tx.send(Err(SetInputError::PlayStream(e.to_string())));
                     return;
                 }
-            };
-
-            if let Err(e) = stream.play() {
-                let _ = ready_tx.send(Err(SetInputError::PlayStream(e.to_string())));
-                return;
-            }
 
-            let _ = ready_tx.send(Ok(()));
+                let _ = ready_tx.send(Ok(()));
 
-            match done_rx.recv() {
-                Ok(_) => {
-                    info!("Microphone actor shut down, ending stream");
-                }
-                Err(_) => {
-                    info!("Microphone actor unreachable, ending stream");
+                match done_rx.recv() {
+                    Ok(_) => {
+                        info!("Microphone actor shut down, ending stream");
+                    }
+                    Err(_) => {
+                        info!("Microphone actor unreachable, ending stream");
+                    }
                 }
             }
         });
@@ -286,18 +357,20 @@ impl Message<SetInput> for MicrophoneFeed {
 }
 
 impl Message<RemoveInput> for MicrophoneFeed {
-    type Reply = ();
+    type Reply = Result<(), FeedLockedError>;
 
     async fn handle(&mut self, _: RemoveInput, _: &mut Context<Self, Self::Reply>) -> Self::Reply {
         trace!("MicrophoneFeed.RemoveInput");
 
-        match std::mem::replace(&mut self.state, State::Detached) {
-            State::Detached => {}
-            State::Initializing { .. } => {}
-            State::Attached { done_tx, .. } => {
-                let _ = done_tx.send(());
-            }
+        let state = self.state.try_as_open()?;
+
+        state.connecting = None;
+
+        if let Some(AttachedState { done_tx, .. }) = state.attached.take() {
+            let _ = done_tx.send(());
         }
+
+        Ok(())
     }
 }
 
@@ -337,64 +410,101 @@ impl Message<MicrophoneSamples> for MicrophoneFeed {
 
 #[derive(Clone, Debug, thiserror::Error)]
 pub enum LockFeedError {
+    #[error(transparent)]
+    Locked(#[from] FeedLockedError),
     #[error("NoInput")]
     NoInput,
-    #[error("InitializeFailed${0}")]
-    InitializeFailed(SetInputError),
+    #[error("InitializeFailed/{0}")]
+    InitializeFailed(#[from] SetInputError),
 }
 
 impl Message<Lock> for MicrophoneFeed {
     type Reply = Result<MicrophoneFeedLock, LockFeedError>;
 
     async fn handle(&mut self, _: Lock, ctx: &mut Context<Self, Self::Reply>) -> Self::Reply {
-        let config = match &mut self.state {
-            State::Detached => return Err(LockFeedError::NoInput),
-            State::Initializing { ready, .. } => {
-                ready.await.map_err(LockFeedError::InitializeFailed)?
-            }
-            State::Attached { config, .. } => config.clone(),
+        trace!("MicrophoneFeed.Lock");
+
+        let state = self.state.try_as_open()?;
+
+        if let Some(connecting) = &mut state.connecting {
+            let ready = &mut connecting.ready;
+            let data = ready.await?;
+
+            state.handle_input_connected(data);
+        }
+
+        let Some(attached) = state.attached.take() else {
+            return Err(LockFeedError::NoInput);
         };
 
+        let config = attached.config.clone();
+
+        self.state = State::Locked { inner: attached };
+
         Ok(MicrophoneFeedLock {
             audio_info: AudioInfo::from_stream_config(&config),
             actor: ctx.actor_ref(),
             config,
+            lock_tx: ctx.actor_ref().recipient(),
         })
     }
 }
 
 impl Message<InputConnected> for MicrophoneFeed {
-    type Reply = ();
+    type Reply = Result<(), FeedLockedError>;
 
     async fn handle(
         &mut self,
         msg: InputConnected,
         _: &mut Context<Self, Self::Reply>,
     ) -> Self::Reply {
-        if let State::Initializing { id, .. } = self.state
-            && id == msg.id
-        {
-            self.state = State::Attached {
-                id: msg.id,
-                config: msg.config,
-                done_tx: msg.done_tx,
-            };
-        }
+        trace!("MicrophoneFeed.InputConnected");
+
+        let state = self.state.try_as_open()?;
+
+        state.handle_input_connected(msg);
+
+        Ok(())
     }
 }
 
 impl Message<InputConnectFailed> for MicrophoneFeed {
-    type Reply = ();
+    type Reply = Result<(), FeedLockedError>;
 
     async fn handle(
         &mut self,
         msg: InputConnectFailed,
         _: &mut Context<Self, Self::Reply>,
     ) -> Self::Reply {
-        if let State::Attached { id, .. } = self.state
-            && id == msg.id
+        trace!("MicrophoneFeed.InputConnectFailed");
+
+        let state = self.state.try_as_open()?;
+
+        if let Some(connecting) = &state.connecting
+            && connecting.id == msg.id
         {
-            self.state = State::Detached;
+            state.connecting = None;
         }
+
+        Ok(())
+    }
+}
+
+impl Message<Unlock> for MicrophoneFeed {
+    type Reply = ();
+
+    async fn handle(&mut self, _: Unlock, _: &mut Context<Self, Self::Reply>) -> Self::Reply {
+        trace!("MicrophoneFeed.Unlock");
+
+        replace_with_or_abort(&mut self.state, |state| {
+            if let State::Locked { inner } = state {
+                State::Open(OpenState {
+                    connecting: None,
+                    attached: Some(inner),
+                })
+            } else {
+                state
+            }
+        });
     }
 }
diff --git a/packages/ui-solid/src/auto-imports.d.ts b/packages/ui-solid/src/auto-imports.d.ts
index 61f7f810c7..87fa550b4a 100644
--- a/packages/ui-solid/src/auto-imports.d.ts
+++ b/packages/ui-solid/src/auto-imports.d.ts
@@ -7,80 +7,80 @@
 export {}
 declare global {
   const IconCapArrows: typeof import('~icons/cap/arrows.jsx')['default']
-  const IconCapAudioOn: typeof import("~icons/cap/audio-on.jsx")["default"]
-  const IconCapBgBlur: typeof import("~icons/cap/bg-blur.jsx")["default"]
+  const IconCapAudioOn: typeof import('~icons/cap/audio-on.jsx')['default']
+  const IconCapBgBlur: typeof import('~icons/cap/bg-blur.jsx')['default']
   const IconCapCamera: typeof import('~icons/cap/camera.jsx')['default']
-  const IconCapCaptions: typeof import("~icons/cap/captions.jsx")["default"]
+  const IconCapCaptions: typeof import('~icons/cap/captions.jsx')['default']
   const IconCapChevronDown: typeof import('~icons/cap/chevron-down.jsx')['default']
   const IconCapCircle: typeof import('~icons/cap/circle.jsx')['default']
-  const IconCapCircleCheck: typeof import("~icons/cap/circle-check.jsx")["default"]
-  const IconCapCirclePlus: typeof import("~icons/cap/circle-plus.jsx")["default"]
+  const IconCapCircleCheck: typeof import('~icons/cap/circle-check.jsx')['default']
+  const IconCapCirclePlus: typeof import('~icons/cap/circle-plus.jsx')['default']
   const IconCapCircleX: typeof import('~icons/cap/circle-x.jsx')['default']
-  const IconCapCopy: typeof import("~icons/cap/copy.jsx")["default"]
-  const IconCapCorners: typeof import("~icons/cap/corners.jsx")["default"]
+  const IconCapCopy: typeof import('~icons/cap/copy.jsx')['default']
+  const IconCapCorners: typeof import('~icons/cap/corners.jsx')['default']
   const IconCapCrop: typeof import('~icons/cap/crop.jsx')['default']
-  const IconCapCursor: typeof import("~icons/cap/cursor.jsx")["default"]
+  const IconCapCursor: typeof import('~icons/cap/cursor.jsx')['default']
   const IconCapEditor: typeof import("~icons/cap/editor.jsx")["default"]
   const IconCapEnlarge: typeof import('~icons/cap/enlarge.jsx')['default']
-  const IconCapFile: typeof import("~icons/cap/file.jsx")["default"]
+  const IconCapFile: typeof import('~icons/cap/file.jsx')['default']
   const IconCapFilmCut: typeof import('~icons/cap/film-cut.jsx')['default']
-  const IconCapGauge: typeof import("~icons/cap/gauge.jsx")["default"]
+  const IconCapGauge: typeof import('~icons/cap/gauge.jsx')['default']
   const IconCapHotkeys: typeof import('~icons/cap/hotkeys.jsx')['default']
-  const IconCapImage: typeof import("~icons/cap/image.jsx")["default"]
+  const IconCapImage: typeof import('~icons/cap/image.jsx')['default']
   const IconCapInfo: typeof import('~icons/cap/info.jsx')['default']
   const IconCapInstant: typeof import('~icons/cap/instant.jsx')['default']
-  const IconCapLayout: typeof import("~icons/cap/layout.jsx")["default"]
-  const IconCapLink: typeof import("~icons/cap/link.jsx")["default"]
+  const IconCapLayout: typeof import('~icons/cap/layout.jsx')['default']
+  const IconCapLink: typeof import('~icons/cap/link.jsx')['default']
   const IconCapLogo: typeof import('~icons/cap/logo.jsx')['default']
   const IconCapLogoFull: typeof import('~icons/cap/logo-full.jsx')['default']
   const IconCapLogoFullDark: typeof import('~icons/cap/logo-full-dark.jsx')['default']
-  const IconCapMessageBubble: typeof import("~icons/cap/message-bubble.jsx")["default"]
+  const IconCapMessageBubble: typeof import('~icons/cap/message-bubble.jsx')['default']
   const IconCapMicrophone: typeof import('~icons/cap/microphone.jsx')['default']
-  const IconCapMoreVertical: typeof import("~icons/cap/more-vertical.jsx")["default"]
-  const IconCapNext: typeof import("~icons/cap/next.jsx")["default"]
-  const IconCapPadding: typeof import("~icons/cap/padding.jsx")["default"]
-  const IconCapPause: typeof import("~icons/cap/pause.jsx")["default"]
-  const IconCapPauseCircle: typeof import("~icons/cap/pause-circle.jsx")["default"]
-  const IconCapPlay: typeof import("~icons/cap/play.jsx")["default"]
-  const IconCapPlayCircle: typeof import("~icons/cap/play-circle.jsx")["default"]
-  const IconCapPresets: typeof import("~icons/cap/presets.jsx")["default"]
-  const IconCapPrev: typeof import("~icons/cap/prev.jsx")["default"]
-  const IconCapRedo: typeof import("~icons/cap/redo.jsx")["default"]
-  const IconCapRestart: typeof import("~icons/cap/restart.jsx")["default"]
-  const IconCapScissors: typeof import("~icons/cap/scissors.jsx")["default"]
+  const IconCapMoreVertical: typeof import('~icons/cap/more-vertical.jsx')['default']
+  const IconCapNext: typeof import('~icons/cap/next.jsx')['default']
+  const IconCapPadding: typeof import('~icons/cap/padding.jsx')['default']
+  const IconCapPause: typeof import('~icons/cap/pause.jsx')['default']
+  const IconCapPauseCircle: typeof import('~icons/cap/pause-circle.jsx')['default']
+  const IconCapPlay: typeof import('~icons/cap/play.jsx')['default']
+  const IconCapPlayCircle: typeof import('~icons/cap/play-circle.jsx')['default']
+  const IconCapPresets: typeof import('~icons/cap/presets.jsx')['default']
+  const IconCapPrev: typeof import('~icons/cap/prev.jsx')['default']
+  const IconCapRedo: typeof import('~icons/cap/redo.jsx')['default']
+  const IconCapRestart: typeof import('~icons/cap/restart.jsx')['default']
+  const IconCapScissors: typeof import('~icons/cap/scissors.jsx')['default']
   const IconCapSettings: typeof import('~icons/cap/settings.jsx')['default']
-  const IconCapShadow: typeof import("~icons/cap/shadow.jsx")["default"]
+  const IconCapShadow: typeof import('~icons/cap/shadow.jsx')['default']
   const IconCapSquare: typeof import('~icons/cap/square.jsx')['default']
-  const IconCapStopCircle: typeof import("~icons/cap/stop-circle.jsx")["default"]
-  const IconCapTrash: typeof import("~icons/cap/trash.jsx")["default"]
-  const IconCapUndo: typeof import("~icons/cap/undo.jsx")["default"]
+  const IconCapStopCircle: typeof import('~icons/cap/stop-circle.jsx')['default']
+  const IconCapTrash: typeof import('~icons/cap/trash.jsx')['default']
+  const IconCapUndo: typeof import('~icons/cap/undo.jsx')['default']
   const IconCapUpload: typeof import("~icons/cap/upload.jsx")["default"]
-  const IconCapZoomIn: typeof import("~icons/cap/zoom-in.jsx")["default"]
-  const IconCapZoomOut: typeof import("~icons/cap/zoom-out.jsx")["default"]
-  const IconHugeiconsEaseCurveControlPoints: typeof import("~icons/hugeicons/ease-curve-control-points.jsx")["default"]
+  const IconCapZoomIn: typeof import('~icons/cap/zoom-in.jsx')['default']
+  const IconCapZoomOut: typeof import('~icons/cap/zoom-out.jsx')['default']
+  const IconHugeiconsEaseCurveControlPoints: typeof import('~icons/hugeicons/ease-curve-control-points.jsx')['default']
   const IconLucideAppWindowMac: typeof import('~icons/lucide/app-window-mac.jsx')['default']
   const IconLucideBell: typeof import('~icons/lucide/bell.jsx')['default']
   const IconLucideBug: typeof import('~icons/lucide/bug.jsx')['default']
   const IconLucideCheck: typeof import('~icons/lucide/check.jsx')['default']
-  const IconLucideClock: typeof import("~icons/lucide/clock.jsx")["default"]
+  const IconLucideClock: typeof import('~icons/lucide/clock.jsx')['default']
   const IconLucideDatabase: typeof import('~icons/lucide/database.jsx')['default']
-  const IconLucideEdit: typeof import("~icons/lucide/edit.jsx")["default"]
+  const IconLucideEdit: typeof import('~icons/lucide/edit.jsx')['default']
   const IconLucideEye: typeof import("~icons/lucide/eye.jsx")["default"]
   const IconLucideEyeOff: typeof import("~icons/lucide/eye-off.jsx")["default"]
-  const IconLucideFolder: typeof import("~icons/lucide/folder.jsx")["default"]
+  const IconLucideFolder: typeof import('~icons/lucide/folder.jsx')['default']
   const IconLucideGift: typeof import('~icons/lucide/gift.jsx')['default']
-  const IconLucideHardDrive: typeof import("~icons/lucide/hard-drive.jsx")["default"]
-  const IconLucideLayout: typeof import("~icons/lucide/layout.jsx")["default"]
-  const IconLucideLoaderCircle: typeof import("~icons/lucide/loader-circle.jsx")["default"]
+  const IconLucideHardDrive: typeof import('~icons/lucide/hard-drive.jsx')['default']
+  const IconLucideLayout: typeof import('~icons/lucide/layout.jsx')['default']
+  const IconLucideLoaderCircle: typeof import('~icons/lucide/loader-circle.jsx')['default']
   const IconLucideMessageSquarePlus: typeof import('~icons/lucide/message-square-plus.jsx')['default']
-  const IconLucideMicOff: typeof import("~icons/lucide/mic-off.jsx")["default"]
-  const IconLucideMonitor: typeof import("~icons/lucide/monitor.jsx")["default"]
+  const IconLucideMicOff: typeof import('~icons/lucide/mic-off.jsx')['default']
+  const IconLucideMonitor: typeof import('~icons/lucide/monitor.jsx')['default']
   const IconLucideRectangleHorizontal: typeof import('~icons/lucide/rectangle-horizontal.jsx')['default']
-  const IconLucideRotateCcw: typeof import("~icons/lucide/rotate-ccw.jsx")["default"]
-  const IconLucideSearch: typeof import("~icons/lucide/search.jsx")["default"]
+  const IconLucideRotateCcw: typeof import('~icons/lucide/rotate-ccw.jsx')['default']
+  const IconLucideSearch: typeof import('~icons/lucide/search.jsx')['default']
   const IconLucideSquarePlay: typeof import('~icons/lucide/square-play.jsx')['default']
   const IconLucideUnplug: typeof import('~icons/lucide/unplug.jsx')['default']
-  const IconLucideVolume2: typeof import("~icons/lucide/volume2.jsx")["default"]
+  const IconLucideVolume2: typeof import('~icons/lucide/volume2.jsx')['default']
   const IconLucideVolumeX: typeof import("~icons/lucide/volume-x.jsx")["default"]
   const IconMaterialSymbolsScreenshotFrame2Rounded: typeof import('~icons/material-symbols/screenshot-frame2-rounded.jsx')['default']
   const IconMdiMonitor: typeof import('~icons/mdi/monitor.jsx')['default']

From 83693595b97a91d81c6c5d3b0aa321c00d7ea366 Mon Sep 17 00:00:00 2001
From: Brendan Allan <brendonovich@outlook.com>
Date: Mon, 25 Aug 2025 18:39:45 +0800
Subject: [PATCH 5/7] cleanuop

---
 apps/desktop/src-tauri/src/lib.rs         |  26 +-
 apps/desktop/src-tauri/src/recording.rs   |   4 +-
 crates/recording/src/feeds/audio_input.rs | 350 ----------------------
 3 files changed, 15 insertions(+), 365 deletions(-)
 delete mode 100644 crates/recording/src/feeds/audio_input.rs

diff --git a/apps/desktop/src-tauri/src/lib.rs b/apps/desktop/src-tauri/src/lib.rs
index 6bab59a16c..716e5dbdf6 100644
--- a/apps/desktop/src-tauri/src/lib.rs
+++ b/apps/desktop/src-tauri/src/lib.rs
@@ -114,7 +114,7 @@ pub struct App {
     #[serde(skip)]
     recording_logging_handle: LoggingHandle,
     #[serde(skip)]
-    mic_feed_actor: ActorRef<feeds::microphone::MicrophoneFeed>,
+    mic_feed: ActorRef<feeds::microphone::MicrophoneFeed>,
     server_url: String,
 }
 
@@ -221,20 +221,22 @@ async fn set_mic_input(state: MutableState<'_, App>, label: Option<String>) -> R
 
     match label {
         None => {
-            let _ = app.mic_feed_actor.ask(microphone::RemoveInput).await;
-
-            Ok(())
+            app.mic_feed
+                .ask(microphone::RemoveInput)
+                .await
+                .map_err(|e| e.to_string())?;
         }
         Some(label) => {
-            let _ = app
-                .mic_feed_actor
+            app.mic_feed
                 .ask(feeds::microphone::SetInput { label })
                 .await
+                .map_err(|e| e.to_string())?
+                .await
                 .map_err(|e| e.to_string())?;
-
-            Ok(())
         }
     }
+
+    Ok(())
 }
 
 #[tauri::command]
@@ -2131,7 +2133,7 @@ pub async fn run(recording_logging_handle: LoggingHandle) {
                     camera_feed_initialization: None,
                     recording_state: RecordingState::None,
                     recording_logging_handle,
-                    mic_feed_actor: mic_feed,
+                    mic_feed,
                     server_url: GeneralSettingsStore::get(&app)
                         .ok()
                         .flatten()
@@ -2220,10 +2222,8 @@ pub async fn run(recording_logging_handle: LoggingHandle) {
                                     let app_state = &mut *state.write().await;
 
                                     if !app_state.is_recording_active_or_pending() {
-                                        let _ = app_state
-                                            .mic_feed_actor
-                                            .ask(microphone::RemoveInput)
-                                            .await;
+                                        let _ =
+                                            app_state.mic_feed.ask(microphone::RemoveInput).await;
                                         app_state.camera_feed.take();
 
                                         if let Some(camera) = CapWindowId::Camera.get(&app) {
diff --git a/apps/desktop/src-tauri/src/recording.rs b/apps/desktop/src-tauri/src/recording.rs
index 62edcb0864..b9892b217f 100644
--- a/apps/desktop/src-tauri/src/recording.rs
+++ b/apps/desktop/src-tauri/src/recording.rs
@@ -353,7 +353,7 @@ pub async fn start_recording(
                 let mut state = state_mtx.write().await;
 
                 use kameo::error::SendError;
-                let mic_feed = match state.mic_feed_actor.ask(microphone::Lock).await {
+                let mic_feed = match state.mic_feed.ask(microphone::Lock).await {
                     Ok(lock) => Some(Arc::new(lock)),
                     Err(SendError::HandlerError(microphone::LockFeedError::NoInput)) => None,
                     Err(e) => return Err(e.to_string()),
@@ -653,7 +653,7 @@ async fn handle_recording_end(
             let _ = v.close();
         }
         app.camera_feed.take();
-        let _ = app.mic_feed_actor.ask(microphone::RemoveInput).await;
+        let _ = app.mic_feed.ask(microphone::RemoveInput).await;
     }
 
     CurrentRecordingChanged.emit(&handle).ok();
diff --git a/crates/recording/src/feeds/audio_input.rs b/crates/recording/src/feeds/audio_input.rs
deleted file mode 100644
index d74378b384..0000000000
--- a/crates/recording/src/feeds/audio_input.rs
+++ /dev/null
@@ -1,350 +0,0 @@
-use cap_fail::fail_err;
-use cap_media_info::{AudioInfo, ffmpeg_sample_format_for};
-use cpal::traits::{DeviceTrait, HostTrait, StreamTrait};
-use cpal::{Device, InputCallbackInfo, SampleFormat, StreamConfig, SupportedStreamConfig};
-use flume::{Receiver, Sender, TrySendError};
-use indexmap::IndexMap;
-use tracing::{debug, error, info, trace, warn};
-
-use crate::MediaError;
-
-#[derive(Clone)]
-pub struct AudioInputSamples {
-    pub data: Vec<u8>,
-    pub format: SampleFormat,
-    pub info: InputCallbackInfo,
-}
-
-pub enum AudioInputControl {
-    Switch(String, Sender<Result<SupportedStreamConfig, MediaError>>),
-    AttachSender(AudioInputSamplesSender),
-    Shutdown,
-}
-
-pub struct AudioInputConnection {
-    control: Sender<AudioInputControl>,
-}
-
-impl AudioInputConnection {
-    pub fn attach(&self) -> Receiver<AudioInputSamples> {
-        let (sender, receiver) = flume::bounded(5);
-        self.control
-            .send(AudioInputControl::AttachSender(sender))
-            .unwrap();
-
-        receiver
-    }
-}
-
-pub type AudioInputSamplesSender = Sender<AudioInputSamples>;
-pub type AudioInputSamplesReceiver = Receiver<AudioInputSamples>;
-
-pub type AudioInputDeviceMap = IndexMap<String, (Device, SupportedStreamConfig)>;
-
-pub const MAX_AUDIO_CHANNELS: u16 = 2;
-
-#[derive(Clone)]
-pub struct AudioInputFeed {
-    pub control_tx: Sender<AudioInputControl>,
-    audio_info: AudioInfo,
-    // rx: Receiver<AudioInputSamples>,
-}
-
-impl AudioInputFeed {
-    pub fn create_channel() -> (AudioInputSamplesSender, AudioInputSamplesReceiver) {
-        flume::bounded(60)
-    }
-
-    pub async fn init(selected_input: &str) -> Result<Self, MediaError> {
-        trace!("Initializing audio input feed with device");
-        debug!(selected_input);
-
-        fail_err!(
-            "media::feeds::audio_input::init",
-            MediaError::Any("".into())
-        );
-
-        let (device, config) = Self::list_devices()
-            .swap_remove_entry(selected_input)
-            .map(|(device_name, (device, config))| {
-                info!(
-                    "Using audio device: {} with config: {:?}",
-                    device_name, config
-                );
-                (device, config)
-            })
-            .ok_or_else(|| {
-                error!("Failed to find audio device: {}", selected_input);
-                MediaError::DeviceUnreachable(selected_input.to_string())
-            })?;
-
-        let audio_info = AudioInfo::from_stream_config(&config);
-
-        debug!("Created audio info: {:?}", audio_info);
-        let (control_tx, control_rx) = flume::bounded(1);
-
-        std::thread::spawn(|| start_capturing(device, config, control_rx));
-        info!("Started audio capture thread");
-
-        Ok(Self {
-            control_tx,
-            audio_info,
-        })
-    }
-
-    pub fn list_devices() -> AudioInputDeviceMap {
-        let host = cpal::default_host();
-        let mut device_map = IndexMap::new();
-
-        let get_usable_device = |device: Device| {
-            device
-                .supported_input_configs()
-                .map_err(|error| {
-                    error!(
-                        "Error getting supported input configs for device: {}",
-                        error
-                    );
-                    error
-                })
-                .ok()
-                .and_then(|configs| {
-                    let mut configs = configs.collect::<Vec<_>>();
-                    configs.sort_by(|a, b| {
-                        b.sample_format()
-                            .sample_size()
-                            .cmp(&a.sample_format().sample_size())
-                            .then(b.max_sample_rate().cmp(&a.max_sample_rate()))
-                    });
-                    configs
-                        .into_iter()
-                        .filter(|c| {
-                            c.min_sample_rate().0 <= 48000 && c.max_sample_rate().0 <= 48000
-                        })
-                        .find(|c| ffmpeg_sample_format_for(c.sample_format()).is_some())
-                })
-                .and_then(|config| {
-                    device
-                        .name()
-                        .ok()
-                        .map(|name| (name, device, config.with_max_sample_rate()))
-                })
-        };
-
-        if let Some((name, device, config)) =
-            host.default_input_device().and_then(get_usable_device)
-        {
-            device_map.insert(name, (device, config));
-        } else {
-            warn!("No default input device found or it's not usable");
-        }
-
-        match host.input_devices() {
-            Ok(devices) => {
-                for (name, device, config) in devices.filter_map(get_usable_device) {
-                    device_map.entry(name).or_insert((device, config));
-                }
-            }
-            Err(error) => {
-                error!("Could not access audio input devices: {}", error);
-            }
-        }
-
-        device_map
-    }
-
-    pub async fn switch_input(&mut self, name: &str) -> Result<(), MediaError> {
-        fail_err!(
-            "media::feeds::audio_input::switch_input",
-            MediaError::Any("".into())
-        );
-
-        let (tx, rx) = flume::bounded(1);
-
-        self.control_tx
-            .send_async(AudioInputControl::Switch(name.to_string(), tx))
-            .await
-            .map_err(|error| {
-                eprintln!("Error while switching audio input: {error}");
-                MediaError::TaskLaunch("Failed to switch audio input".into())
-            })?;
-
-        let config = rx.recv_async().await.map_err(|error| {
-            eprintln!("Error while switching audio input: {error}");
-            MediaError::TaskLaunch("Failed to switch audio input".into())
-        })??;
-
-        self.audio_info = AudioInfo::from_stream_config(&config);
-
-        Ok(())
-    }
-
-    pub async fn add_sender(&self, sender: AudioInputSamplesSender) -> Result<(), MediaError> {
-        self.control_tx
-            .send_async(AudioInputControl::AttachSender(sender))
-            .await
-            .map_err(|error| {
-                eprintln!("Error while attaching audio input sender: {error}");
-                MediaError::TaskLaunch("Failed to attach audio input sender".into())
-            })?;
-
-        Ok(())
-    }
-
-    pub fn audio_info(&self) -> AudioInfo {
-        self.audio_info
-    }
-
-    pub fn create_connection(&self) -> AudioInputConnection {
-        AudioInputConnection {
-            control: self.control_tx.clone(),
-        }
-    }
-}
-
-fn start_capturing(
-    mut device: Device,
-    mut config: SupportedStreamConfig,
-    control: Receiver<AudioInputControl>,
-) {
-    debug!(
-        "Starting audio capture with device: {:?}, config: {:?}",
-        device.name(),
-        config
-    );
-    let mut senders: Vec<AudioInputSamplesSender> = vec![];
-
-    loop {
-        let (tx, rx) = flume::bounded(4);
-        debug!("Building input stream with config: {:?}", config);
-
-        let stream_config: StreamConfig = config.clone().into();
-        let stream = match device.build_input_stream_raw(
-            &stream_config,
-            config.sample_format(),
-            move |data, info| {
-                if let Err(e) = tx.send(AudioInputSamples {
-                    data: data.bytes().to_vec(),
-                    format: data.sample_format(),
-                    info: info.clone(),
-                }) {
-                    error!("Failed to send audio samples: {}", e);
-                }
-            },
-            |e| {
-                error!("Error in audio input stream: {}", e);
-            },
-            None,
-        ) {
-            Ok(stream) => {
-                info!("Successfully built audio input stream");
-                stream
-            }
-            Err(err) => {
-                error!("Failed to build audio input stream: {}", err);
-                // Sleep briefly to avoid tight error loop
-                std::thread::sleep(std::time::Duration::from_secs(1));
-                continue;
-            }
-        };
-
-        // Try to play the stream
-        if let Err(e) = stream.play() {
-            error!("Failed to start audio stream playback: {}", e);
-            continue;
-        }
-        info!("Audio stream playback started");
-
-        loop {
-            match control.try_recv() {
-                Ok(AudioInputControl::Switch(name, response)) => {
-                    if device.name().unwrap() == name {
-                        response.send(Ok(config.clone())).unwrap();
-                        continue;
-                    }
-
-                    debug!("Switching audio device to: {}", name);
-                    // list_devices hangs if the stream isn't dropped
-                    drop(stream);
-                    let Some(items) = AudioInputFeed::list_devices().swap_remove_entry(&name).map(
-                        |(device_name, (device, config))| {
-                            info!(
-                                "Switched to audio device: {} with config: {:?}",
-                                device_name, config
-                            );
-                            (device, config)
-                        },
-                    ) else {
-                        error!("Failed to find audio device: {}", name);
-                        response
-                            .send(Err(MediaError::DeviceUnreachable(name)))
-                            .unwrap();
-                        break;
-                    };
-
-                    device = items.0;
-                    config = items.1;
-
-                    response.send(Ok(config.clone())).unwrap();
-                    break;
-                }
-                Ok(AudioInputControl::Shutdown) => {
-                    debug!("Received shutdown signal for audio capture");
-                    return;
-                }
-                Ok(AudioInputControl::AttachSender(sender)) => {
-                    senders.push(sender);
-                    info!("New audio sender attached");
-                }
-                Err(flume::TryRecvError::Disconnected) => {
-                    warn!("Control receiver is unreachable! Shutting down audio capture");
-                    return;
-                }
-                Err(flume::TryRecvError::Empty) => {
-                    // No signal received, nothing to do
-                }
-            }
-
-            match rx.recv() {
-                Ok(mut data) => {
-                    let mut to_remove = vec![];
-
-                    if config.channels() > MAX_AUDIO_CHANNELS {
-                        let mut new_data = Vec::with_capacity(
-                            MAX_AUDIO_CHANNELS as usize
-                                * (data.data.len() / config.channels() as usize),
-                        );
-
-                        let sample_size = data.format.sample_size();
-
-                        for sample in data.data.chunks(sample_size * config.channels() as usize) {
-                            new_data.extend_from_slice(
-                                &sample[0..sample_size * MAX_AUDIO_CHANNELS as usize],
-                            );
-                        }
-
-                        data.data = new_data;
-                    }
-
-                    for (i, sender) in senders.iter().enumerate() {
-                        if let Err(TrySendError::Disconnected(_)) = sender.try_send(data.clone()) {
-                            warn!("Audio sender {} disconnected, will be removed", i);
-                            to_remove.push(i);
-                        };
-                    }
-
-                    if !to_remove.is_empty() {
-                        debug!("Removing {} disconnected audio senders", to_remove.len());
-                        for i in to_remove.into_iter().rev() {
-                            senders.swap_remove(i);
-                        }
-                    }
-                }
-                Err(error) => {
-                    error!("Failed to capture audio samples: {:?}", error);
-                    // Break inner loop to recreate the stream
-                    break;
-                }
-            }
-        }
-    }
-}

From dca0b1f4dc1957a2d98cbb9d485a7177be2b2005 Mon Sep 17 00:00:00 2001
From: Brendan Allan <brendonovich@outlook.com>
Date: Mon, 25 Aug 2025 18:41:16 +0800
Subject: [PATCH 6/7] formatting

---
 apps/desktop/src/utils/queries.ts       |   15 +-
 apps/desktop/src/utils/tauri.ts         | 1233 +++++++++++++++--------
 packages/ui-solid/src/auto-imports.d.ts |  160 +--
 3 files changed, 879 insertions(+), 529 deletions(-)

diff --git a/apps/desktop/src/utils/queries.ts b/apps/desktop/src/utils/queries.ts
index 0d85c86783..ceafcc1cb5 100644
--- a/apps/desktop/src/utils/queries.ts
+++ b/apps/desktop/src/utils/queries.ts
@@ -173,12 +173,15 @@ export function createCameraMutation() {
 		mutationFn: rawMutate,
 	}));
 
-	return new Proxy(setCameraInput as typeof setCameraInput & { rawMutate: typeof rawMutate }, {
-		get(target, key) {
-			if (key === 'rawMutate') return rawMutate;
-			return Reflect.get(target, key);
-		}
-	});
+	return new Proxy(
+		setCameraInput as typeof setCameraInput & { rawMutate: typeof rawMutate },
+		{
+			get(target, key) {
+				if (key === "rawMutate") return rawMutate;
+				return Reflect.get(target, key);
+			},
+		},
+	);
 }
 
 export function createCustomDomainQuery() {
diff --git a/apps/desktop/src/utils/tauri.ts b/apps/desktop/src/utils/tauri.ts
index e3141c6921..41170046ff 100644
--- a/apps/desktop/src/utils/tauri.ts
+++ b/apps/desktop/src/utils/tauri.ts
@@ -1,465 +1,813 @@
-
 // This file was generated by [tauri-specta](https://github.com/oscartbeaumont/tauri-specta). Do not edit this file manually.
 
 /** user-defined commands **/
 
-
 export const commands = {
-async setMicInput(label: string | null) : Promise<null> {
-    return await TAURI_INVOKE("set_mic_input", { label });
-},
-async setCameraInput(id: DeviceOrModelID | null) : Promise<boolean> {
-    return await TAURI_INVOKE("set_camera_input", { id });
-},
-async startRecording(inputs: StartRecordingInputs) : Promise<null> {
-    return await TAURI_INVOKE("start_recording", { inputs });
-},
-async stopRecording() : Promise<null> {
-    return await TAURI_INVOKE("stop_recording");
-},
-async pauseRecording() : Promise<null> {
-    return await TAURI_INVOKE("pause_recording");
-},
-async resumeRecording() : Promise<null> {
-    return await TAURI_INVOKE("resume_recording");
-},
-async restartRecording() : Promise<null> {
-    return await TAURI_INVOKE("restart_recording");
-},
-async deleteRecording() : Promise<null> {
-    return await TAURI_INVOKE("delete_recording");
-},
-async listCameras() : Promise<CameraInfo[]> {
-    return await TAURI_INVOKE("list_cameras");
-},
-async listCaptureWindows() : Promise<CaptureWindow[]> {
-    return await TAURI_INVOKE("list_capture_windows");
-},
-async listCaptureDisplays() : Promise<CaptureDisplay[]> {
-    return await TAURI_INVOKE("list_capture_displays");
-},
-async takeScreenshot() : Promise<null> {
-    return await TAURI_INVOKE("take_screenshot");
-},
-async listAudioDevices() : Promise<string[]> {
-    return await TAURI_INVOKE("list_audio_devices");
-},
-async closeRecordingsOverlayWindow() : Promise<void> {
-    await TAURI_INVOKE("close_recordings_overlay_window");
-},
-async setFakeWindowBounds(name: string, bounds: LogicalBounds) : Promise<null> {
-    return await TAURI_INVOKE("set_fake_window_bounds", { name, bounds });
-},
-async removeFakeWindow(name: string) : Promise<null> {
-    return await TAURI_INVOKE("remove_fake_window", { name });
-},
-async focusCapturesPanel() : Promise<void> {
-    await TAURI_INVOKE("focus_captures_panel");
-},
-async getCurrentRecording() : Promise<JsonValue<CurrentRecording | null>> {
-    return await TAURI_INVOKE("get_current_recording");
-},
-async exportVideo(projectPath: string, progress: TAURI_CHANNEL<FramesRendered>, settings: ExportSettings) : Promise<string> {
-    return await TAURI_INVOKE("export_video", { projectPath, progress, settings });
-},
-async getExportEstimates(path: string, resolution: XY<number>, fps: number) : Promise<ExportEstimates> {
-    return await TAURI_INVOKE("get_export_estimates", { path, resolution, fps });
-},
-async copyFileToPath(src: string, dst: string) : Promise<null> {
-    return await TAURI_INVOKE("copy_file_to_path", { src, dst });
-},
-async copyVideoToClipboard(path: string) : Promise<null> {
-    return await TAURI_INVOKE("copy_video_to_clipboard", { path });
-},
-async copyScreenshotToClipboard(path: string) : Promise<null> {
-    return await TAURI_INVOKE("copy_screenshot_to_clipboard", { path });
-},
-async openFilePath(path: string) : Promise<null> {
-    return await TAURI_INVOKE("open_file_path", { path });
-},
-async getVideoMetadata(path: string) : Promise<VideoRecordingMetadata> {
-    return await TAURI_INVOKE("get_video_metadata", { path });
-},
-async createEditorInstance() : Promise<SerializedEditorInstance> {
-    return await TAURI_INVOKE("create_editor_instance");
-},
-async getMicWaveforms() : Promise<number[][]> {
-    return await TAURI_INVOKE("get_mic_waveforms");
-},
-async getSystemAudioWaveforms() : Promise<number[][]> {
-    return await TAURI_INVOKE("get_system_audio_waveforms");
-},
-async startPlayback(fps: number, resolutionBase: XY<number>) : Promise<null> {
-    return await TAURI_INVOKE("start_playback", { fps, resolutionBase });
-},
-async stopPlayback() : Promise<null> {
-    return await TAURI_INVOKE("stop_playback");
-},
-async setPlayheadPosition(frameNumber: number) : Promise<null> {
-    return await TAURI_INVOKE("set_playhead_position", { frameNumber });
-},
-async setProjectConfig(config: ProjectConfiguration) : Promise<null> {
-    return await TAURI_INVOKE("set_project_config", { config });
-},
-async generateZoomSegmentsFromClicks() : Promise<ZoomSegment[]> {
-    return await TAURI_INVOKE("generate_zoom_segments_from_clicks");
-},
-async openPermissionSettings(permission: OSPermission) : Promise<void> {
-    await TAURI_INVOKE("open_permission_settings", { permission });
-},
-async doPermissionsCheck(initialCheck: boolean) : Promise<OSPermissionsCheck> {
-    return await TAURI_INVOKE("do_permissions_check", { initialCheck });
-},
-async requestPermission(permission: OSPermission) : Promise<void> {
-    await TAURI_INVOKE("request_permission", { permission });
-},
-async uploadExportedVideo(path: string, mode: UploadMode) : Promise<UploadResult> {
-    return await TAURI_INVOKE("upload_exported_video", { path, mode });
-},
-async uploadScreenshot(screenshotPath: string) : Promise<UploadResult> {
-    return await TAURI_INVOKE("upload_screenshot", { screenshotPath });
-},
-async getRecordingMeta(path: string, fileType: FileType) : Promise<RecordingMetaWithType> {
-    return await TAURI_INVOKE("get_recording_meta", { path, fileType });
-},
-async saveFileDialog(fileName: string, fileType: string) : Promise<string | null> {
-    return await TAURI_INVOKE("save_file_dialog", { fileName, fileType });
-},
-async listRecordings() : Promise<([string, RecordingMetaWithType])[]> {
-    return await TAURI_INVOKE("list_recordings");
-},
-async listScreenshots() : Promise<([string, RecordingMeta])[]> {
-    return await TAURI_INVOKE("list_screenshots");
-},
-async checkUpgradedAndUpdate() : Promise<boolean> {
-    return await TAURI_INVOKE("check_upgraded_and_update");
-},
-async openExternalLink(url: string) : Promise<null> {
-    return await TAURI_INVOKE("open_external_link", { url });
-},
-async setHotkey(action: HotkeyAction, hotkey: Hotkey | null) : Promise<null> {
-    return await TAURI_INVOKE("set_hotkey", { action, hotkey });
-},
-async resetCameraPermissions() : Promise<null> {
-    return await TAURI_INVOKE("reset_camera_permissions");
-},
-async resetMicrophonePermissions() : Promise<null> {
-    return await TAURI_INVOKE("reset_microphone_permissions");
-},
-async isCameraWindowOpen() : Promise<boolean> {
-    return await TAURI_INVOKE("is_camera_window_open");
-},
-async seekTo(frameNumber: number) : Promise<null> {
-    return await TAURI_INVOKE("seek_to", { frameNumber });
-},
-async positionTrafficLights(controlsInset: [number, number] | null) : Promise<void> {
-    await TAURI_INVOKE("position_traffic_lights", { controlsInset });
-},
-async setTheme(theme: AppTheme) : Promise<void> {
-    await TAURI_INVOKE("set_theme", { theme });
-},
-async globalMessageDialog(message: string) : Promise<void> {
-    await TAURI_INVOKE("global_message_dialog", { message });
-},
-async showWindow(window: ShowCapWindow) : Promise<null> {
-    return await TAURI_INVOKE("show_window", { window });
-},
-async writeClipboardString(text: string) : Promise<null> {
-    return await TAURI_INVOKE("write_clipboard_string", { text });
-},
-async performHapticFeedback(pattern: HapticPattern | null, time: HapticPerformanceTime | null) : Promise<null> {
-    return await TAURI_INVOKE("perform_haptic_feedback", { pattern, time });
-},
-async listFails() : Promise<{ [key in string]: boolean }> {
-    return await TAURI_INVOKE("list_fails");
-},
-async setFail(name: string, value: boolean) : Promise<void> {
-    await TAURI_INVOKE("set_fail", { name, value });
-},
-async updateAuthPlan() : Promise<void> {
-    await TAURI_INVOKE("update_auth_plan");
-},
-async setWindowTransparent(value: boolean) : Promise<void> {
-    await TAURI_INVOKE("set_window_transparent", { value });
-},
-async getEditorMeta() : Promise<RecordingMeta> {
-    return await TAURI_INVOKE("get_editor_meta");
-},
-async setPrettyName(prettyName: string) : Promise<null> {
-    return await TAURI_INVOKE("set_pretty_name", { prettyName });
-},
-async setServerUrl(serverUrl: string) : Promise<null> {
-    return await TAURI_INVOKE("set_server_url", { serverUrl });
-},
-async setCameraPreviewState(state: CameraWindowState) : Promise<null> {
-    return await TAURI_INVOKE("set_camera_preview_state", { state });
-},
-async awaitCameraPreviewReady() : Promise<boolean> {
-    return await TAURI_INVOKE("await_camera_preview_ready");
-},
-/**
- * Function to handle creating directories for the model
- */
-async createDir(path: string, recursive: boolean) : Promise<null> {
-    return await TAURI_INVOKE("create_dir", { path, recursive });
-},
-/**
- * Function to save the model file
- */
-async saveModelFile(path: string, data: number[]) : Promise<null> {
-    return await TAURI_INVOKE("save_model_file", { path, data });
-},
-/**
- * Function to transcribe audio from a video file using Whisper
- */
-async transcribeAudio(videoPath: string, modelPath: string, language: string) : Promise<CaptionData> {
-    return await TAURI_INVOKE("transcribe_audio", { videoPath, modelPath, language });
-},
-/**
- * Function to save caption data to a file
- */
-async saveCaptions(videoId: string, captions: CaptionData) : Promise<null> {
-    return await TAURI_INVOKE("save_captions", { videoId, captions });
-},
-/**
- * Function to load caption data from a file
- */
-async loadCaptions(videoId: string) : Promise<CaptionData | null> {
-    return await TAURI_INVOKE("load_captions", { videoId });
-},
-/**
- * Helper function to download a Whisper model from Hugging Face Hub
- */
-async downloadWhisperModel(modelName: string, outputPath: string) : Promise<null> {
-    return await TAURI_INVOKE("download_whisper_model", { modelName, outputPath });
-},
-/**
- * Function to check if a model file exists
- */
-async checkModelExists(modelPath: string) : Promise<boolean> {
-    return await TAURI_INVOKE("check_model_exists", { modelPath });
-},
-/**
- * Function to delete a downloaded model
- */
-async deleteWhisperModel(modelPath: string) : Promise<null> {
-    return await TAURI_INVOKE("delete_whisper_model", { modelPath });
-},
-/**
- * Export captions to an SRT file
- */
-async exportCaptionsSrt(videoId: string) : Promise<string | null> {
-    return await TAURI_INVOKE("export_captions_srt", { videoId });
-},
-async openTargetSelectOverlays() : Promise<null> {
-    return await TAURI_INVOKE("open_target_select_overlays");
-},
-async closeTargetSelectOverlays() : Promise<null> {
-    return await TAURI_INVOKE("close_target_select_overlays");
-}
-}
+	async setMicInput(label: string | null): Promise<null> {
+		return await TAURI_INVOKE("set_mic_input", { label });
+	},
+	async setCameraInput(id: DeviceOrModelID | null): Promise<boolean> {
+		return await TAURI_INVOKE("set_camera_input", { id });
+	},
+	async startRecording(inputs: StartRecordingInputs): Promise<null> {
+		return await TAURI_INVOKE("start_recording", { inputs });
+	},
+	async stopRecording(): Promise<null> {
+		return await TAURI_INVOKE("stop_recording");
+	},
+	async pauseRecording(): Promise<null> {
+		return await TAURI_INVOKE("pause_recording");
+	},
+	async resumeRecording(): Promise<null> {
+		return await TAURI_INVOKE("resume_recording");
+	},
+	async restartRecording(): Promise<null> {
+		return await TAURI_INVOKE("restart_recording");
+	},
+	async deleteRecording(): Promise<null> {
+		return await TAURI_INVOKE("delete_recording");
+	},
+	async listCameras(): Promise<CameraInfo[]> {
+		return await TAURI_INVOKE("list_cameras");
+	},
+	async listCaptureWindows(): Promise<CaptureWindow[]> {
+		return await TAURI_INVOKE("list_capture_windows");
+	},
+	async listCaptureDisplays(): Promise<CaptureDisplay[]> {
+		return await TAURI_INVOKE("list_capture_displays");
+	},
+	async takeScreenshot(): Promise<null> {
+		return await TAURI_INVOKE("take_screenshot");
+	},
+	async listAudioDevices(): Promise<string[]> {
+		return await TAURI_INVOKE("list_audio_devices");
+	},
+	async closeRecordingsOverlayWindow(): Promise<void> {
+		await TAURI_INVOKE("close_recordings_overlay_window");
+	},
+	async setFakeWindowBounds(
+		name: string,
+		bounds: LogicalBounds,
+	): Promise<null> {
+		return await TAURI_INVOKE("set_fake_window_bounds", { name, bounds });
+	},
+	async removeFakeWindow(name: string): Promise<null> {
+		return await TAURI_INVOKE("remove_fake_window", { name });
+	},
+	async focusCapturesPanel(): Promise<void> {
+		await TAURI_INVOKE("focus_captures_panel");
+	},
+	async getCurrentRecording(): Promise<JsonValue<CurrentRecording | null>> {
+		return await TAURI_INVOKE("get_current_recording");
+	},
+	async exportVideo(
+		projectPath: string,
+		progress: TAURI_CHANNEL<FramesRendered>,
+		settings: ExportSettings,
+	): Promise<string> {
+		return await TAURI_INVOKE("export_video", {
+			projectPath,
+			progress,
+			settings,
+		});
+	},
+	async getExportEstimates(
+		path: string,
+		resolution: XY<number>,
+		fps: number,
+	): Promise<ExportEstimates> {
+		return await TAURI_INVOKE("get_export_estimates", {
+			path,
+			resolution,
+			fps,
+		});
+	},
+	async copyFileToPath(src: string, dst: string): Promise<null> {
+		return await TAURI_INVOKE("copy_file_to_path", { src, dst });
+	},
+	async copyVideoToClipboard(path: string): Promise<null> {
+		return await TAURI_INVOKE("copy_video_to_clipboard", { path });
+	},
+	async copyScreenshotToClipboard(path: string): Promise<null> {
+		return await TAURI_INVOKE("copy_screenshot_to_clipboard", { path });
+	},
+	async openFilePath(path: string): Promise<null> {
+		return await TAURI_INVOKE("open_file_path", { path });
+	},
+	async getVideoMetadata(path: string): Promise<VideoRecordingMetadata> {
+		return await TAURI_INVOKE("get_video_metadata", { path });
+	},
+	async createEditorInstance(): Promise<SerializedEditorInstance> {
+		return await TAURI_INVOKE("create_editor_instance");
+	},
+	async getMicWaveforms(): Promise<number[][]> {
+		return await TAURI_INVOKE("get_mic_waveforms");
+	},
+	async getSystemAudioWaveforms(): Promise<number[][]> {
+		return await TAURI_INVOKE("get_system_audio_waveforms");
+	},
+	async startPlayback(fps: number, resolutionBase: XY<number>): Promise<null> {
+		return await TAURI_INVOKE("start_playback", { fps, resolutionBase });
+	},
+	async stopPlayback(): Promise<null> {
+		return await TAURI_INVOKE("stop_playback");
+	},
+	async setPlayheadPosition(frameNumber: number): Promise<null> {
+		return await TAURI_INVOKE("set_playhead_position", { frameNumber });
+	},
+	async setProjectConfig(config: ProjectConfiguration): Promise<null> {
+		return await TAURI_INVOKE("set_project_config", { config });
+	},
+	async generateZoomSegmentsFromClicks(): Promise<ZoomSegment[]> {
+		return await TAURI_INVOKE("generate_zoom_segments_from_clicks");
+	},
+	async openPermissionSettings(permission: OSPermission): Promise<void> {
+		await TAURI_INVOKE("open_permission_settings", { permission });
+	},
+	async doPermissionsCheck(initialCheck: boolean): Promise<OSPermissionsCheck> {
+		return await TAURI_INVOKE("do_permissions_check", { initialCheck });
+	},
+	async requestPermission(permission: OSPermission): Promise<void> {
+		await TAURI_INVOKE("request_permission", { permission });
+	},
+	async uploadExportedVideo(
+		path: string,
+		mode: UploadMode,
+	): Promise<UploadResult> {
+		return await TAURI_INVOKE("upload_exported_video", { path, mode });
+	},
+	async uploadScreenshot(screenshotPath: string): Promise<UploadResult> {
+		return await TAURI_INVOKE("upload_screenshot", { screenshotPath });
+	},
+	async getRecordingMeta(
+		path: string,
+		fileType: FileType,
+	): Promise<RecordingMetaWithType> {
+		return await TAURI_INVOKE("get_recording_meta", { path, fileType });
+	},
+	async saveFileDialog(
+		fileName: string,
+		fileType: string,
+	): Promise<string | null> {
+		return await TAURI_INVOKE("save_file_dialog", { fileName, fileType });
+	},
+	async listRecordings(): Promise<[string, RecordingMetaWithType][]> {
+		return await TAURI_INVOKE("list_recordings");
+	},
+	async listScreenshots(): Promise<[string, RecordingMeta][]> {
+		return await TAURI_INVOKE("list_screenshots");
+	},
+	async checkUpgradedAndUpdate(): Promise<boolean> {
+		return await TAURI_INVOKE("check_upgraded_and_update");
+	},
+	async openExternalLink(url: string): Promise<null> {
+		return await TAURI_INVOKE("open_external_link", { url });
+	},
+	async setHotkey(action: HotkeyAction, hotkey: Hotkey | null): Promise<null> {
+		return await TAURI_INVOKE("set_hotkey", { action, hotkey });
+	},
+	async resetCameraPermissions(): Promise<null> {
+		return await TAURI_INVOKE("reset_camera_permissions");
+	},
+	async resetMicrophonePermissions(): Promise<null> {
+		return await TAURI_INVOKE("reset_microphone_permissions");
+	},
+	async isCameraWindowOpen(): Promise<boolean> {
+		return await TAURI_INVOKE("is_camera_window_open");
+	},
+	async seekTo(frameNumber: number): Promise<null> {
+		return await TAURI_INVOKE("seek_to", { frameNumber });
+	},
+	async positionTrafficLights(
+		controlsInset: [number, number] | null,
+	): Promise<void> {
+		await TAURI_INVOKE("position_traffic_lights", { controlsInset });
+	},
+	async setTheme(theme: AppTheme): Promise<void> {
+		await TAURI_INVOKE("set_theme", { theme });
+	},
+	async globalMessageDialog(message: string): Promise<void> {
+		await TAURI_INVOKE("global_message_dialog", { message });
+	},
+	async showWindow(window: ShowCapWindow): Promise<null> {
+		return await TAURI_INVOKE("show_window", { window });
+	},
+	async writeClipboardString(text: string): Promise<null> {
+		return await TAURI_INVOKE("write_clipboard_string", { text });
+	},
+	async performHapticFeedback(
+		pattern: HapticPattern | null,
+		time: HapticPerformanceTime | null,
+	): Promise<null> {
+		return await TAURI_INVOKE("perform_haptic_feedback", { pattern, time });
+	},
+	async listFails(): Promise<{ [key in string]: boolean }> {
+		return await TAURI_INVOKE("list_fails");
+	},
+	async setFail(name: string, value: boolean): Promise<void> {
+		await TAURI_INVOKE("set_fail", { name, value });
+	},
+	async updateAuthPlan(): Promise<void> {
+		await TAURI_INVOKE("update_auth_plan");
+	},
+	async setWindowTransparent(value: boolean): Promise<void> {
+		await TAURI_INVOKE("set_window_transparent", { value });
+	},
+	async getEditorMeta(): Promise<RecordingMeta> {
+		return await TAURI_INVOKE("get_editor_meta");
+	},
+	async setPrettyName(prettyName: string): Promise<null> {
+		return await TAURI_INVOKE("set_pretty_name", { prettyName });
+	},
+	async setServerUrl(serverUrl: string): Promise<null> {
+		return await TAURI_INVOKE("set_server_url", { serverUrl });
+	},
+	async setCameraPreviewState(state: CameraWindowState): Promise<null> {
+		return await TAURI_INVOKE("set_camera_preview_state", { state });
+	},
+	async awaitCameraPreviewReady(): Promise<boolean> {
+		return await TAURI_INVOKE("await_camera_preview_ready");
+	},
+	/**
+	 * Function to handle creating directories for the model
+	 */
+	async createDir(path: string, recursive: boolean): Promise<null> {
+		return await TAURI_INVOKE("create_dir", { path, recursive });
+	},
+	/**
+	 * Function to save the model file
+	 */
+	async saveModelFile(path: string, data: number[]): Promise<null> {
+		return await TAURI_INVOKE("save_model_file", { path, data });
+	},
+	/**
+	 * Function to transcribe audio from a video file using Whisper
+	 */
+	async transcribeAudio(
+		videoPath: string,
+		modelPath: string,
+		language: string,
+	): Promise<CaptionData> {
+		return await TAURI_INVOKE("transcribe_audio", {
+			videoPath,
+			modelPath,
+			language,
+		});
+	},
+	/**
+	 * Function to save caption data to a file
+	 */
+	async saveCaptions(videoId: string, captions: CaptionData): Promise<null> {
+		return await TAURI_INVOKE("save_captions", { videoId, captions });
+	},
+	/**
+	 * Function to load caption data from a file
+	 */
+	async loadCaptions(videoId: string): Promise<CaptionData | null> {
+		return await TAURI_INVOKE("load_captions", { videoId });
+	},
+	/**
+	 * Helper function to download a Whisper model from Hugging Face Hub
+	 */
+	async downloadWhisperModel(
+		modelName: string,
+		outputPath: string,
+	): Promise<null> {
+		return await TAURI_INVOKE("download_whisper_model", {
+			modelName,
+			outputPath,
+		});
+	},
+	/**
+	 * Function to check if a model file exists
+	 */
+	async checkModelExists(modelPath: string): Promise<boolean> {
+		return await TAURI_INVOKE("check_model_exists", { modelPath });
+	},
+	/**
+	 * Function to delete a downloaded model
+	 */
+	async deleteWhisperModel(modelPath: string): Promise<null> {
+		return await TAURI_INVOKE("delete_whisper_model", { modelPath });
+	},
+	/**
+	 * Export captions to an SRT file
+	 */
+	async exportCaptionsSrt(videoId: string): Promise<string | null> {
+		return await TAURI_INVOKE("export_captions_srt", { videoId });
+	},
+	async openTargetSelectOverlays(): Promise<null> {
+		return await TAURI_INVOKE("open_target_select_overlays");
+	},
+	async closeTargetSelectOverlays(): Promise<null> {
+		return await TAURI_INVOKE("close_target_select_overlays");
+	},
+};
 
 /** user-defined events **/
 
-
 export const events = __makeEvents__<{
-audioInputLevelChange: AudioInputLevelChange,
-authenticationInvalid: AuthenticationInvalid,
-currentRecordingChanged: CurrentRecordingChanged,
-downloadProgress: DownloadProgress,
-editorStateChanged: EditorStateChanged,
-newNotification: NewNotification,
-newScreenshotAdded: NewScreenshotAdded,
-newStudioRecordingAdded: NewStudioRecordingAdded,
-onEscapePress: OnEscapePress,
-recordingDeleted: RecordingDeleted,
-recordingEvent: RecordingEvent,
-recordingOptionsChanged: RecordingOptionsChanged,
-recordingStarted: RecordingStarted,
-recordingStopped: RecordingStopped,
-renderFrameEvent: RenderFrameEvent,
-requestNewScreenshot: RequestNewScreenshot,
-requestOpenSettings: RequestOpenSettings,
-requestStartRecording: RequestStartRecording,
-targetUnderCursor: TargetUnderCursor,
-uploadProgress: UploadProgress
+	audioInputLevelChange: AudioInputLevelChange;
+	authenticationInvalid: AuthenticationInvalid;
+	currentRecordingChanged: CurrentRecordingChanged;
+	downloadProgress: DownloadProgress;
+	editorStateChanged: EditorStateChanged;
+	newNotification: NewNotification;
+	newScreenshotAdded: NewScreenshotAdded;
+	newStudioRecordingAdded: NewStudioRecordingAdded;
+	onEscapePress: OnEscapePress;
+	recordingDeleted: RecordingDeleted;
+	recordingEvent: RecordingEvent;
+	recordingOptionsChanged: RecordingOptionsChanged;
+	recordingStarted: RecordingStarted;
+	recordingStopped: RecordingStopped;
+	renderFrameEvent: RenderFrameEvent;
+	requestNewScreenshot: RequestNewScreenshot;
+	requestOpenSettings: RequestOpenSettings;
+	requestStartRecording: RequestStartRecording;
+	targetUnderCursor: TargetUnderCursor;
+	uploadProgress: UploadProgress;
 }>({
-audioInputLevelChange: "audio-input-level-change",
-authenticationInvalid: "authentication-invalid",
-currentRecordingChanged: "current-recording-changed",
-downloadProgress: "download-progress",
-editorStateChanged: "editor-state-changed",
-newNotification: "new-notification",
-newScreenshotAdded: "new-screenshot-added",
-newStudioRecordingAdded: "new-studio-recording-added",
-onEscapePress: "on-escape-press",
-recordingDeleted: "recording-deleted",
-recordingEvent: "recording-event",
-recordingOptionsChanged: "recording-options-changed",
-recordingStarted: "recording-started",
-recordingStopped: "recording-stopped",
-renderFrameEvent: "render-frame-event",
-requestNewScreenshot: "request-new-screenshot",
-requestOpenSettings: "request-open-settings",
-requestStartRecording: "request-start-recording",
-targetUnderCursor: "target-under-cursor",
-uploadProgress: "upload-progress"
-})
+	audioInputLevelChange: "audio-input-level-change",
+	authenticationInvalid: "authentication-invalid",
+	currentRecordingChanged: "current-recording-changed",
+	downloadProgress: "download-progress",
+	editorStateChanged: "editor-state-changed",
+	newNotification: "new-notification",
+	newScreenshotAdded: "new-screenshot-added",
+	newStudioRecordingAdded: "new-studio-recording-added",
+	onEscapePress: "on-escape-press",
+	recordingDeleted: "recording-deleted",
+	recordingEvent: "recording-event",
+	recordingOptionsChanged: "recording-options-changed",
+	recordingStarted: "recording-started",
+	recordingStopped: "recording-stopped",
+	renderFrameEvent: "render-frame-event",
+	requestNewScreenshot: "request-new-screenshot",
+	requestOpenSettings: "request-open-settings",
+	requestStartRecording: "request-start-recording",
+	targetUnderCursor: "target-under-cursor",
+	uploadProgress: "upload-progress",
+});
 
 /** user-defined constants **/
 
-
-
 /** user-defined types **/
 
-export type AppTheme = "system" | "light" | "dark"
-export type AspectRatio = "wide" | "vertical" | "square" | "classic" | "tall"
-export type Audio = { duration: number; sample_rate: number; channels: number; start_time: number }
-export type AudioConfiguration = { mute: boolean; improve: boolean; micVolumeDb?: number; micStereoMode?: StereoMode; systemVolumeDb?: number }
-export type AudioInputLevelChange = number
-export type AudioMeta = { path: string; 
-/**
- * unix time of the first frame
- */
-start_time?: number | null }
-export type AuthSecret = { api_key: string } | { token: string; expires: number }
-export type AuthStore = { secret: AuthSecret; user_id: string | null; plan: Plan | null; intercom_hash: string | null }
-export type AuthenticationInvalid = null
-export type BackgroundConfiguration = { source: BackgroundSource; blur: number; padding: number; rounding: number; inset: number; crop: Crop | null; shadow?: number; advancedShadow?: ShadowConfiguration | null }
-export type BackgroundSource = { type: "wallpaper"; path: string | null } | { type: "image"; path: string | null } | { type: "color"; value: [number, number, number] } | { type: "gradient"; from: [number, number, number]; to: [number, number, number]; angle?: number }
-export type Camera = { hide: boolean; mirror: boolean; position: CameraPosition; size: number; zoom_size: number | null; rounding?: number; shadow?: number; advanced_shadow?: ShadowConfiguration | null; shape?: CameraShape }
-export type CameraInfo = { device_id: string; model_id: ModelIDType | null; display_name: string }
-export type CameraPosition = { x: CameraXPosition; y: CameraYPosition }
-export type CameraPreviewShape = "round" | "square" | "full"
-export type CameraPreviewSize = "sm" | "lg"
-export type CameraShape = "square" | "source"
-export type CameraWindowState = { size: CameraPreviewSize; shape: CameraPreviewShape; mirrored: boolean }
-export type CameraXPosition = "left" | "center" | "right"
-export type CameraYPosition = "top" | "bottom"
-export type CaptionData = { segments: CaptionSegment[]; settings: CaptionSettings | null }
-export type CaptionSegment = { id: string; start: number; end: number; text: string }
-export type CaptionSettings = { enabled: boolean; font: string; size: number; color: string; backgroundColor: string; backgroundOpacity: number; position: string; bold: boolean; italic: boolean; outline: boolean; outlineColor: string; exportWithSubtitles: boolean }
-export type CaptionsData = { segments: CaptionSegment[]; settings: CaptionSettings }
-export type CaptureDisplay = { id: DisplayId; name: string; refresh_rate: number }
-export type CaptureWindow = { id: WindowId; owner_name: string; name: string; bounds: LogicalBounds; refresh_rate: number }
-export type CommercialLicense = { licenseKey: string; expiryDate: number | null; refresh: number; activatedOn: number }
-export type Crop = { position: XY<number>; size: XY<number> }
-export type CurrentRecording = { target: CurrentRecordingTarget; type: RecordingType }
-export type CurrentRecordingChanged = null
-export type CurrentRecordingTarget = { window: { id: WindowId; bounds: LogicalBounds } } | { screen: { id: DisplayId } } | { area: { screen: DisplayId; bounds: LogicalBounds } }
-export type CursorAnimationStyle = "regular" | "slow" | "fast"
-export type CursorConfiguration = { hide?: boolean; hideWhenIdle: boolean; size: number; type: CursorType; animationStyle: CursorAnimationStyle; tension: number; mass: number; friction: number; raw?: boolean; motionBlur?: number; useSvg?: boolean }
-export type CursorMeta = { imagePath: string; hotspot: XY<number>; shape?: string | null }
-export type CursorType = "pointer" | "circle"
-export type Cursors = { [key in string]: string } | { [key in string]: CursorMeta }
-export type DeviceOrModelID = { DeviceID: string } | { ModelID: ModelIDType }
-export type DisplayId = string
-export type DownloadProgress = { progress: number; message: string }
-export type EditorStateChanged = { playhead_position: number }
-export type ExportCompression = "Minimal" | "Social" | "Web" | "Potato"
-export type ExportEstimates = { duration_seconds: number; estimated_time_seconds: number; estimated_size_mb: number }
-export type ExportSettings = ({ format: "Mp4" } & Mp4ExportSettings) | ({ format: "Gif" } & GifExportSettings)
-export type FileType = "recording" | "screenshot"
-export type Flags = { captions: boolean }
-export type FramesRendered = { renderedCount: number; totalFrames: number; type: "FramesRendered" }
-export type GeneralSettingsStore = { instanceId?: string; uploadIndividualFiles?: boolean; hideDockIcon?: boolean; hapticsEnabled?: boolean; autoCreateShareableLink?: boolean; enableNotifications?: boolean; disableAutoOpenLinks?: boolean; hasCompletedStartup?: boolean; theme?: AppTheme; commercialLicense?: CommercialLicense | null; lastVersion?: string | null; windowTransparency?: boolean; postStudioRecordingBehaviour?: PostStudioRecordingBehaviour; mainWindowRecordingStartBehaviour?: MainWindowRecordingStartBehaviour; customCursorCapture?: boolean; serverUrl?: string; recordingCountdown?: number | null; enableNativeCameraPreview: boolean; autoZoomOnClicks?: boolean; enableNewRecordingFlow: boolean; postDeletionBehaviour?: PostDeletionBehaviour }
-export type GifExportSettings = { fps: number; resolution_base: XY<number>; quality: GifQuality | null }
-export type GifQuality = { 
-/**
- * Encoding quality from 1-100 (default: 90)
- */
-quality: number | null; 
-/**
- * Whether to prioritize speed over quality (default: false)
- */
-fast: boolean | null }
-export type HapticPattern = "Alignment" | "LevelChange" | "Generic"
-export type HapticPerformanceTime = "Default" | "Now" | "DrawCompleted"
-export type Hotkey = { code: string; meta: boolean; ctrl: boolean; alt: boolean; shift: boolean }
-export type HotkeyAction = "startRecording" | "stopRecording" | "restartRecording"
-export type HotkeysConfiguration = { show: boolean }
-export type HotkeysStore = { hotkeys: { [key in HotkeyAction]: Hotkey } }
-export type InstantRecordingMeta = { fps: number; sample_rate: number | null }
-export type JsonValue<T> = [T]
-export type LayoutMode = "default" | "cameraOnly" | "hideCamera"
-export type LayoutSegment = { start: number; end: number; mode?: LayoutMode }
-export type LogicalBounds = { position: LogicalPosition; size: LogicalSize }
-export type LogicalPosition = { x: number; y: number }
-export type LogicalSize = { width: number; height: number }
-export type MainWindowRecordingStartBehaviour = "close" | "minimise"
-export type ModelIDType = string
-export type Mp4ExportSettings = { fps: number; resolution_base: XY<number>; compression: ExportCompression }
-export type MultipleSegment = { display: VideoMeta; camera?: VideoMeta | null; mic?: AudioMeta | null; system_audio?: AudioMeta | null; cursor?: string | null }
-export type MultipleSegments = { segments: MultipleSegment[]; cursors: Cursors }
-export type NewNotification = { title: string; body: string; is_error: boolean }
-export type NewScreenshotAdded = { path: string }
-export type NewStudioRecordingAdded = { path: string }
-export type OSPermission = "screenRecording" | "camera" | "microphone" | "accessibility"
-export type OSPermissionStatus = "notNeeded" | "empty" | "granted" | "denied"
-export type OSPermissionsCheck = { screenRecording: OSPermissionStatus; microphone: OSPermissionStatus; camera: OSPermissionStatus; accessibility: OSPermissionStatus }
-export type OnEscapePress = null
-export type PhysicalSize = { width: number; height: number }
-export type Plan = { upgraded: boolean; manual: boolean; last_checked: number }
-export type Platform = "MacOS" | "Windows"
-export type PostDeletionBehaviour = "doNothing" | "reopenRecordingWindow"
-export type PostStudioRecordingBehaviour = "openEditor" | "showOverlay"
-export type Preset = { name: string; config: ProjectConfiguration }
-export type PresetsStore = { presets: Preset[]; default: number | null }
-export type ProjectConfiguration = { aspectRatio: AspectRatio | null; background: BackgroundConfiguration; camera: Camera; audio: AudioConfiguration; cursor: CursorConfiguration; hotkeys: HotkeysConfiguration; timeline?: TimelineConfiguration | null; captions?: CaptionsData | null }
-export type ProjectRecordingsMeta = { segments: SegmentRecordings[] }
-export type RecordingDeleted = { path: string }
-export type RecordingEvent = { variant: "Countdown"; value: number } | { variant: "Started" } | { variant: "Stopped" } | { variant: "Failed"; error: string }
-export type RecordingMeta = (StudioRecordingMeta | InstantRecordingMeta) & { platform?: Platform | null; pretty_name: string; sharing?: SharingMeta | null }
-export type RecordingMetaWithType = ((StudioRecordingMeta | InstantRecordingMeta) & { platform?: Platform | null; pretty_name: string; sharing?: SharingMeta | null }) & { type: RecordingType }
-export type RecordingMode = "studio" | "instant"
-export type RecordingOptionsChanged = null
-export type RecordingStarted = null
-export type RecordingStopped = null
-export type RecordingType = "studio" | "instant"
-export type RenderFrameEvent = { frame_number: number; fps: number; resolution_base: XY<number> }
-export type RequestNewScreenshot = null
-export type RequestOpenSettings = { page: string }
-export type RequestStartRecording = null
-export type S3UploadMeta = { id: string }
-export type ScreenCaptureTarget = { variant: "window"; id: WindowId } | { variant: "display"; id: DisplayId } | { variant: "area"; screen: DisplayId; bounds: LogicalBounds }
-export type ScreenUnderCursor = { name: string; physical_size: PhysicalSize; refresh_rate: string }
-export type SegmentRecordings = { display: Video; camera: Video | null; mic: Audio | null; system_audio: Audio | null }
-export type SerializedEditorInstance = { framesSocketUrl: string; recordingDuration: number; savedProjectConfig: ProjectConfiguration; recordings: ProjectRecordingsMeta; path: string }
-export type ShadowConfiguration = { size: number; opacity: number; blur: number }
-export type SharingMeta = { id: string; link: string }
-export type ShowCapWindow = "Setup" | "Main" | { Settings: { page: string | null } } | { Editor: { project_path: string } } | "RecordingsOverlay" | { WindowCaptureOccluder: { screen_id: DisplayId } } | { TargetSelectOverlay: { display_id: DisplayId } } | { CaptureArea: { screen_id: DisplayId } } | "Camera" | { InProgressRecording: { countdown: number | null } } | "Upgrade" | "ModeSelect"
-export type SingleSegment = { display: VideoMeta; camera?: VideoMeta | null; audio?: AudioMeta | null; cursor?: string | null }
-export type StartRecordingInputs = { capture_target: ScreenCaptureTarget; capture_system_audio?: boolean; mode: RecordingMode }
-export type StereoMode = "stereo" | "monoL" | "monoR"
-export type StudioRecordingMeta = { segment: SingleSegment } | { inner: MultipleSegments }
-export type TargetUnderCursor = { display_id: DisplayId | null; window: WindowUnderCursor | null; screen: ScreenUnderCursor | null }
-export type TimelineConfiguration = { segments: TimelineSegment[]; zoomSegments: ZoomSegment[]; layoutSegments?: LayoutSegment[] }
-export type TimelineSegment = { recordingSegment?: number; timescale: number; start: number; end: number }
-export type UploadMode = { Initial: { pre_created_video: VideoUploadInfo | null } } | "Reupload"
-export type UploadProgress = { progress: number }
-export type UploadResult = { Success: string } | "NotAuthenticated" | "PlanCheckFailed" | "UpgradeRequired"
-export type Video = { duration: number; width: number; height: number; fps: number; start_time: number }
-export type VideoMeta = { path: string; fps?: number; 
-/**
- * unix time of the first frame
- */
-start_time?: number | null }
-export type VideoRecordingMetadata = { duration: number; size: number }
-export type VideoUploadInfo = { id: string; link: string; config: S3UploadMeta }
-export type WindowId = string
-export type WindowUnderCursor = { id: WindowId; app_name: string; bounds: LogicalBounds; icon: string | null }
-export type XY<T> = { x: T; y: T }
-export type ZoomMode = "auto" | { manual: { x: number; y: number } }
-export type ZoomSegment = { start: number; end: number; amount: number; mode: ZoomMode }
+export type AppTheme = "system" | "light" | "dark";
+export type AspectRatio = "wide" | "vertical" | "square" | "classic" | "tall";
+export type Audio = {
+	duration: number;
+	sample_rate: number;
+	channels: number;
+	start_time: number;
+};
+export type AudioConfiguration = {
+	mute: boolean;
+	improve: boolean;
+	micVolumeDb?: number;
+	micStereoMode?: StereoMode;
+	systemVolumeDb?: number;
+};
+export type AudioInputLevelChange = number;
+export type AudioMeta = {
+	path: string;
+	/**
+	 * unix time of the first frame
+	 */
+	start_time?: number | null;
+};
+export type AuthSecret =
+	| { api_key: string }
+	| { token: string; expires: number };
+export type AuthStore = {
+	secret: AuthSecret;
+	user_id: string | null;
+	plan: Plan | null;
+	intercom_hash: string | null;
+};
+export type AuthenticationInvalid = null;
+export type BackgroundConfiguration = {
+	source: BackgroundSource;
+	blur: number;
+	padding: number;
+	rounding: number;
+	inset: number;
+	crop: Crop | null;
+	shadow?: number;
+	advancedShadow?: ShadowConfiguration | null;
+};
+export type BackgroundSource =
+	| { type: "wallpaper"; path: string | null }
+	| { type: "image"; path: string | null }
+	| { type: "color"; value: [number, number, number] }
+	| {
+			type: "gradient";
+			from: [number, number, number];
+			to: [number, number, number];
+			angle?: number;
+	  };
+export type Camera = {
+	hide: boolean;
+	mirror: boolean;
+	position: CameraPosition;
+	size: number;
+	zoom_size: number | null;
+	rounding?: number;
+	shadow?: number;
+	advanced_shadow?: ShadowConfiguration | null;
+	shape?: CameraShape;
+};
+export type CameraInfo = {
+	device_id: string;
+	model_id: ModelIDType | null;
+	display_name: string;
+};
+export type CameraPosition = { x: CameraXPosition; y: CameraYPosition };
+export type CameraPreviewShape = "round" | "square" | "full";
+export type CameraPreviewSize = "sm" | "lg";
+export type CameraShape = "square" | "source";
+export type CameraWindowState = {
+	size: CameraPreviewSize;
+	shape: CameraPreviewShape;
+	mirrored: boolean;
+};
+export type CameraXPosition = "left" | "center" | "right";
+export type CameraYPosition = "top" | "bottom";
+export type CaptionData = {
+	segments: CaptionSegment[];
+	settings: CaptionSettings | null;
+};
+export type CaptionSegment = {
+	id: string;
+	start: number;
+	end: number;
+	text: string;
+};
+export type CaptionSettings = {
+	enabled: boolean;
+	font: string;
+	size: number;
+	color: string;
+	backgroundColor: string;
+	backgroundOpacity: number;
+	position: string;
+	bold: boolean;
+	italic: boolean;
+	outline: boolean;
+	outlineColor: string;
+	exportWithSubtitles: boolean;
+};
+export type CaptionsData = {
+	segments: CaptionSegment[];
+	settings: CaptionSettings;
+};
+export type CaptureDisplay = {
+	id: DisplayId;
+	name: string;
+	refresh_rate: number;
+};
+export type CaptureWindow = {
+	id: WindowId;
+	owner_name: string;
+	name: string;
+	bounds: LogicalBounds;
+	refresh_rate: number;
+};
+export type CommercialLicense = {
+	licenseKey: string;
+	expiryDate: number | null;
+	refresh: number;
+	activatedOn: number;
+};
+export type Crop = { position: XY<number>; size: XY<number> };
+export type CurrentRecording = {
+	target: CurrentRecordingTarget;
+	type: RecordingType;
+};
+export type CurrentRecordingChanged = null;
+export type CurrentRecordingTarget =
+	| { window: { id: WindowId; bounds: LogicalBounds } }
+	| { screen: { id: DisplayId } }
+	| { area: { screen: DisplayId; bounds: LogicalBounds } };
+export type CursorAnimationStyle = "regular" | "slow" | "fast";
+export type CursorConfiguration = {
+	hide?: boolean;
+	hideWhenIdle: boolean;
+	size: number;
+	type: CursorType;
+	animationStyle: CursorAnimationStyle;
+	tension: number;
+	mass: number;
+	friction: number;
+	raw?: boolean;
+	motionBlur?: number;
+	useSvg?: boolean;
+};
+export type CursorMeta = {
+	imagePath: string;
+	hotspot: XY<number>;
+	shape?: string | null;
+};
+export type CursorType = "pointer" | "circle";
+export type Cursors =
+	| { [key in string]: string }
+	| { [key in string]: CursorMeta };
+export type DeviceOrModelID = { DeviceID: string } | { ModelID: ModelIDType };
+export type DisplayId = string;
+export type DownloadProgress = { progress: number; message: string };
+export type EditorStateChanged = { playhead_position: number };
+export type ExportCompression = "Minimal" | "Social" | "Web" | "Potato";
+export type ExportEstimates = {
+	duration_seconds: number;
+	estimated_time_seconds: number;
+	estimated_size_mb: number;
+};
+export type ExportSettings =
+	| ({ format: "Mp4" } & Mp4ExportSettings)
+	| ({ format: "Gif" } & GifExportSettings);
+export type FileType = "recording" | "screenshot";
+export type Flags = { captions: boolean };
+export type FramesRendered = {
+	renderedCount: number;
+	totalFrames: number;
+	type: "FramesRendered";
+};
+export type GeneralSettingsStore = {
+	instanceId?: string;
+	uploadIndividualFiles?: boolean;
+	hideDockIcon?: boolean;
+	hapticsEnabled?: boolean;
+	autoCreateShareableLink?: boolean;
+	enableNotifications?: boolean;
+	disableAutoOpenLinks?: boolean;
+	hasCompletedStartup?: boolean;
+	theme?: AppTheme;
+	commercialLicense?: CommercialLicense | null;
+	lastVersion?: string | null;
+	windowTransparency?: boolean;
+	postStudioRecordingBehaviour?: PostStudioRecordingBehaviour;
+	mainWindowRecordingStartBehaviour?: MainWindowRecordingStartBehaviour;
+	customCursorCapture?: boolean;
+	serverUrl?: string;
+	recordingCountdown?: number | null;
+	enableNativeCameraPreview: boolean;
+	autoZoomOnClicks?: boolean;
+	enableNewRecordingFlow: boolean;
+	postDeletionBehaviour?: PostDeletionBehaviour;
+};
+export type GifExportSettings = {
+	fps: number;
+	resolution_base: XY<number>;
+	quality: GifQuality | null;
+};
+export type GifQuality = {
+	/**
+	 * Encoding quality from 1-100 (default: 90)
+	 */
+	quality: number | null;
+	/**
+	 * Whether to prioritize speed over quality (default: false)
+	 */
+	fast: boolean | null;
+};
+export type HapticPattern = "Alignment" | "LevelChange" | "Generic";
+export type HapticPerformanceTime = "Default" | "Now" | "DrawCompleted";
+export type Hotkey = {
+	code: string;
+	meta: boolean;
+	ctrl: boolean;
+	alt: boolean;
+	shift: boolean;
+};
+export type HotkeyAction =
+	| "startRecording"
+	| "stopRecording"
+	| "restartRecording";
+export type HotkeysConfiguration = { show: boolean };
+export type HotkeysStore = { hotkeys: { [key in HotkeyAction]: Hotkey } };
+export type InstantRecordingMeta = { fps: number; sample_rate: number | null };
+export type JsonValue<T> = [T];
+export type LayoutMode = "default" | "cameraOnly" | "hideCamera";
+export type LayoutSegment = { start: number; end: number; mode?: LayoutMode };
+export type LogicalBounds = { position: LogicalPosition; size: LogicalSize };
+export type LogicalPosition = { x: number; y: number };
+export type LogicalSize = { width: number; height: number };
+export type MainWindowRecordingStartBehaviour = "close" | "minimise";
+export type ModelIDType = string;
+export type Mp4ExportSettings = {
+	fps: number;
+	resolution_base: XY<number>;
+	compression: ExportCompression;
+};
+export type MultipleSegment = {
+	display: VideoMeta;
+	camera?: VideoMeta | null;
+	mic?: AudioMeta | null;
+	system_audio?: AudioMeta | null;
+	cursor?: string | null;
+};
+export type MultipleSegments = {
+	segments: MultipleSegment[];
+	cursors: Cursors;
+};
+export type NewNotification = {
+	title: string;
+	body: string;
+	is_error: boolean;
+};
+export type NewScreenshotAdded = { path: string };
+export type NewStudioRecordingAdded = { path: string };
+export type OSPermission =
+	| "screenRecording"
+	| "camera"
+	| "microphone"
+	| "accessibility";
+export type OSPermissionStatus = "notNeeded" | "empty" | "granted" | "denied";
+export type OSPermissionsCheck = {
+	screenRecording: OSPermissionStatus;
+	microphone: OSPermissionStatus;
+	camera: OSPermissionStatus;
+	accessibility: OSPermissionStatus;
+};
+export type OnEscapePress = null;
+export type PhysicalSize = { width: number; height: number };
+export type Plan = { upgraded: boolean; manual: boolean; last_checked: number };
+export type Platform = "MacOS" | "Windows";
+export type PostDeletionBehaviour = "doNothing" | "reopenRecordingWindow";
+export type PostStudioRecordingBehaviour = "openEditor" | "showOverlay";
+export type Preset = { name: string; config: ProjectConfiguration };
+export type PresetsStore = { presets: Preset[]; default: number | null };
+export type ProjectConfiguration = {
+	aspectRatio: AspectRatio | null;
+	background: BackgroundConfiguration;
+	camera: Camera;
+	audio: AudioConfiguration;
+	cursor: CursorConfiguration;
+	hotkeys: HotkeysConfiguration;
+	timeline?: TimelineConfiguration | null;
+	captions?: CaptionsData | null;
+};
+export type ProjectRecordingsMeta = { segments: SegmentRecordings[] };
+export type RecordingDeleted = { path: string };
+export type RecordingEvent =
+	| { variant: "Countdown"; value: number }
+	| { variant: "Started" }
+	| { variant: "Stopped" }
+	| { variant: "Failed"; error: string };
+export type RecordingMeta = (StudioRecordingMeta | InstantRecordingMeta) & {
+	platform?: Platform | null;
+	pretty_name: string;
+	sharing?: SharingMeta | null;
+};
+export type RecordingMetaWithType = ((
+	| StudioRecordingMeta
+	| InstantRecordingMeta
+) & {
+	platform?: Platform | null;
+	pretty_name: string;
+	sharing?: SharingMeta | null;
+}) & { type: RecordingType };
+export type RecordingMode = "studio" | "instant";
+export type RecordingOptionsChanged = null;
+export type RecordingStarted = null;
+export type RecordingStopped = null;
+export type RecordingType = "studio" | "instant";
+export type RenderFrameEvent = {
+	frame_number: number;
+	fps: number;
+	resolution_base: XY<number>;
+};
+export type RequestNewScreenshot = null;
+export type RequestOpenSettings = { page: string };
+export type RequestStartRecording = null;
+export type S3UploadMeta = { id: string };
+export type ScreenCaptureTarget =
+	| { variant: "window"; id: WindowId }
+	| { variant: "display"; id: DisplayId }
+	| { variant: "area"; screen: DisplayId; bounds: LogicalBounds };
+export type ScreenUnderCursor = {
+	name: string;
+	physical_size: PhysicalSize;
+	refresh_rate: string;
+};
+export type SegmentRecordings = {
+	display: Video;
+	camera: Video | null;
+	mic: Audio | null;
+	system_audio: Audio | null;
+};
+export type SerializedEditorInstance = {
+	framesSocketUrl: string;
+	recordingDuration: number;
+	savedProjectConfig: ProjectConfiguration;
+	recordings: ProjectRecordingsMeta;
+	path: string;
+};
+export type ShadowConfiguration = {
+	size: number;
+	opacity: number;
+	blur: number;
+};
+export type SharingMeta = { id: string; link: string };
+export type ShowCapWindow =
+	| "Setup"
+	| "Main"
+	| { Settings: { page: string | null } }
+	| { Editor: { project_path: string } }
+	| "RecordingsOverlay"
+	| { WindowCaptureOccluder: { screen_id: DisplayId } }
+	| { TargetSelectOverlay: { display_id: DisplayId } }
+	| { CaptureArea: { screen_id: DisplayId } }
+	| "Camera"
+	| { InProgressRecording: { countdown: number | null } }
+	| "Upgrade"
+	| "ModeSelect";
+export type SingleSegment = {
+	display: VideoMeta;
+	camera?: VideoMeta | null;
+	audio?: AudioMeta | null;
+	cursor?: string | null;
+};
+export type StartRecordingInputs = {
+	capture_target: ScreenCaptureTarget;
+	capture_system_audio?: boolean;
+	mode: RecordingMode;
+};
+export type StereoMode = "stereo" | "monoL" | "monoR";
+export type StudioRecordingMeta =
+	| { segment: SingleSegment }
+	| { inner: MultipleSegments };
+export type TargetUnderCursor = {
+	display_id: DisplayId | null;
+	window: WindowUnderCursor | null;
+	screen: ScreenUnderCursor | null;
+};
+export type TimelineConfiguration = {
+	segments: TimelineSegment[];
+	zoomSegments: ZoomSegment[];
+	layoutSegments?: LayoutSegment[];
+};
+export type TimelineSegment = {
+	recordingSegment?: number;
+	timescale: number;
+	start: number;
+	end: number;
+};
+export type UploadMode =
+	| { Initial: { pre_created_video: VideoUploadInfo | null } }
+	| "Reupload";
+export type UploadProgress = { progress: number };
+export type UploadResult =
+	| { Success: string }
+	| "NotAuthenticated"
+	| "PlanCheckFailed"
+	| "UpgradeRequired";
+export type Video = {
+	duration: number;
+	width: number;
+	height: number;
+	fps: number;
+	start_time: number;
+};
+export type VideoMeta = {
+	path: string;
+	fps?: number;
+	/**
+	 * unix time of the first frame
+	 */
+	start_time?: number | null;
+};
+export type VideoRecordingMetadata = { duration: number; size: number };
+export type VideoUploadInfo = {
+	id: string;
+	link: string;
+	config: S3UploadMeta;
+};
+export type WindowId = string;
+export type WindowUnderCursor = {
+	id: WindowId;
+	app_name: string;
+	bounds: LogicalBounds;
+	icon: string | null;
+};
+export type XY<T> = { x: T; y: T };
+export type ZoomMode = "auto" | { manual: { x: number; y: number } };
+export type ZoomSegment = {
+	start: number;
+	end: number;
+	amount: number;
+	mode: ZoomMode;
+};
 
 /** tauri-specta globals **/
 
 import {
+	type Channel as TAURI_CHANNEL,
 	invoke as TAURI_INVOKE,
-	Channel as TAURI_CHANNEL,
 } from "@tauri-apps/api/core";
 import * as TAURI_API_EVENT from "@tauri-apps/api/event";
-import { type WebviewWindow as __WebviewWindow__ } from "@tauri-apps/api/webviewWindow";
+import type { WebviewWindow as __WebviewWindow__ } from "@tauri-apps/api/webviewWindow";
 
 type __EventObj__<T> = {
 	listen: (
@@ -482,9 +830,8 @@ function __makeEvents__<T extends Record<string, any>>(
 ) {
 	return new Proxy(
 		{} as unknown as {
-			[K in keyof T]: __EventObj__<T[K]> & {
-				(handle: __WebviewWindow__): __EventObj__<T[K]>;
-			};
+			[K in keyof T]: __EventObj__<T[K]> &
+				((handle: __WebviewWindow__) => __EventObj__<T[K]>);
 		},
 		{
 			get: (_, event) => {
diff --git a/packages/ui-solid/src/auto-imports.d.ts b/packages/ui-solid/src/auto-imports.d.ts
index 87fa550b4a..0dfc727b51 100644
--- a/packages/ui-solid/src/auto-imports.d.ts
+++ b/packages/ui-solid/src/auto-imports.d.ts
@@ -4,85 +4,85 @@
 // noinspection JSUnusedGlobalSymbols
 // Generated by unplugin-auto-import
 // biome-ignore lint: disable
-export {}
+export {};
 declare global {
-  const IconCapArrows: typeof import('~icons/cap/arrows.jsx')['default']
-  const IconCapAudioOn: typeof import('~icons/cap/audio-on.jsx')['default']
-  const IconCapBgBlur: typeof import('~icons/cap/bg-blur.jsx')['default']
-  const IconCapCamera: typeof import('~icons/cap/camera.jsx')['default']
-  const IconCapCaptions: typeof import('~icons/cap/captions.jsx')['default']
-  const IconCapChevronDown: typeof import('~icons/cap/chevron-down.jsx')['default']
-  const IconCapCircle: typeof import('~icons/cap/circle.jsx')['default']
-  const IconCapCircleCheck: typeof import('~icons/cap/circle-check.jsx')['default']
-  const IconCapCirclePlus: typeof import('~icons/cap/circle-plus.jsx')['default']
-  const IconCapCircleX: typeof import('~icons/cap/circle-x.jsx')['default']
-  const IconCapCopy: typeof import('~icons/cap/copy.jsx')['default']
-  const IconCapCorners: typeof import('~icons/cap/corners.jsx')['default']
-  const IconCapCrop: typeof import('~icons/cap/crop.jsx')['default']
-  const IconCapCursor: typeof import('~icons/cap/cursor.jsx')['default']
-  const IconCapEditor: typeof import("~icons/cap/editor.jsx")["default"]
-  const IconCapEnlarge: typeof import('~icons/cap/enlarge.jsx')['default']
-  const IconCapFile: typeof import('~icons/cap/file.jsx')['default']
-  const IconCapFilmCut: typeof import('~icons/cap/film-cut.jsx')['default']
-  const IconCapGauge: typeof import('~icons/cap/gauge.jsx')['default']
-  const IconCapHotkeys: typeof import('~icons/cap/hotkeys.jsx')['default']
-  const IconCapImage: typeof import('~icons/cap/image.jsx')['default']
-  const IconCapInfo: typeof import('~icons/cap/info.jsx')['default']
-  const IconCapInstant: typeof import('~icons/cap/instant.jsx')['default']
-  const IconCapLayout: typeof import('~icons/cap/layout.jsx')['default']
-  const IconCapLink: typeof import('~icons/cap/link.jsx')['default']
-  const IconCapLogo: typeof import('~icons/cap/logo.jsx')['default']
-  const IconCapLogoFull: typeof import('~icons/cap/logo-full.jsx')['default']
-  const IconCapLogoFullDark: typeof import('~icons/cap/logo-full-dark.jsx')['default']
-  const IconCapMessageBubble: typeof import('~icons/cap/message-bubble.jsx')['default']
-  const IconCapMicrophone: typeof import('~icons/cap/microphone.jsx')['default']
-  const IconCapMoreVertical: typeof import('~icons/cap/more-vertical.jsx')['default']
-  const IconCapNext: typeof import('~icons/cap/next.jsx')['default']
-  const IconCapPadding: typeof import('~icons/cap/padding.jsx')['default']
-  const IconCapPause: typeof import('~icons/cap/pause.jsx')['default']
-  const IconCapPauseCircle: typeof import('~icons/cap/pause-circle.jsx')['default']
-  const IconCapPlay: typeof import('~icons/cap/play.jsx')['default']
-  const IconCapPlayCircle: typeof import('~icons/cap/play-circle.jsx')['default']
-  const IconCapPresets: typeof import('~icons/cap/presets.jsx')['default']
-  const IconCapPrev: typeof import('~icons/cap/prev.jsx')['default']
-  const IconCapRedo: typeof import('~icons/cap/redo.jsx')['default']
-  const IconCapRestart: typeof import('~icons/cap/restart.jsx')['default']
-  const IconCapScissors: typeof import('~icons/cap/scissors.jsx')['default']
-  const IconCapSettings: typeof import('~icons/cap/settings.jsx')['default']
-  const IconCapShadow: typeof import('~icons/cap/shadow.jsx')['default']
-  const IconCapSquare: typeof import('~icons/cap/square.jsx')['default']
-  const IconCapStopCircle: typeof import('~icons/cap/stop-circle.jsx')['default']
-  const IconCapTrash: typeof import('~icons/cap/trash.jsx')['default']
-  const IconCapUndo: typeof import('~icons/cap/undo.jsx')['default']
-  const IconCapUpload: typeof import("~icons/cap/upload.jsx")["default"]
-  const IconCapZoomIn: typeof import('~icons/cap/zoom-in.jsx')['default']
-  const IconCapZoomOut: typeof import('~icons/cap/zoom-out.jsx')['default']
-  const IconHugeiconsEaseCurveControlPoints: typeof import('~icons/hugeicons/ease-curve-control-points.jsx')['default']
-  const IconLucideAppWindowMac: typeof import('~icons/lucide/app-window-mac.jsx')['default']
-  const IconLucideBell: typeof import('~icons/lucide/bell.jsx')['default']
-  const IconLucideBug: typeof import('~icons/lucide/bug.jsx')['default']
-  const IconLucideCheck: typeof import('~icons/lucide/check.jsx')['default']
-  const IconLucideClock: typeof import('~icons/lucide/clock.jsx')['default']
-  const IconLucideDatabase: typeof import('~icons/lucide/database.jsx')['default']
-  const IconLucideEdit: typeof import('~icons/lucide/edit.jsx')['default']
-  const IconLucideEye: typeof import("~icons/lucide/eye.jsx")["default"]
-  const IconLucideEyeOff: typeof import("~icons/lucide/eye-off.jsx")["default"]
-  const IconLucideFolder: typeof import('~icons/lucide/folder.jsx')['default']
-  const IconLucideGift: typeof import('~icons/lucide/gift.jsx')['default']
-  const IconLucideHardDrive: typeof import('~icons/lucide/hard-drive.jsx')['default']
-  const IconLucideLayout: typeof import('~icons/lucide/layout.jsx')['default']
-  const IconLucideLoaderCircle: typeof import('~icons/lucide/loader-circle.jsx')['default']
-  const IconLucideMessageSquarePlus: typeof import('~icons/lucide/message-square-plus.jsx')['default']
-  const IconLucideMicOff: typeof import('~icons/lucide/mic-off.jsx')['default']
-  const IconLucideMonitor: typeof import('~icons/lucide/monitor.jsx')['default']
-  const IconLucideRectangleHorizontal: typeof import('~icons/lucide/rectangle-horizontal.jsx')['default']
-  const IconLucideRotateCcw: typeof import('~icons/lucide/rotate-ccw.jsx')['default']
-  const IconLucideSearch: typeof import('~icons/lucide/search.jsx')['default']
-  const IconLucideSquarePlay: typeof import('~icons/lucide/square-play.jsx')['default']
-  const IconLucideUnplug: typeof import('~icons/lucide/unplug.jsx')['default']
-  const IconLucideVolume2: typeof import('~icons/lucide/volume2.jsx')['default']
-  const IconLucideVolumeX: typeof import("~icons/lucide/volume-x.jsx")["default"]
-  const IconMaterialSymbolsScreenshotFrame2Rounded: typeof import('~icons/material-symbols/screenshot-frame2-rounded.jsx')['default']
-  const IconMdiMonitor: typeof import('~icons/mdi/monitor.jsx')['default']
-  const IconPhMonitorBold: typeof import('~icons/ph/monitor-bold.jsx')['default']
+	const IconCapArrows: typeof import("~icons/cap/arrows.jsx")["default"];
+	const IconCapAudioOn: typeof import("~icons/cap/audio-on.jsx")["default"];
+	const IconCapBgBlur: typeof import("~icons/cap/bg-blur.jsx")["default"];
+	const IconCapCamera: typeof import("~icons/cap/camera.jsx")["default"];
+	const IconCapCaptions: typeof import("~icons/cap/captions.jsx")["default"];
+	const IconCapChevronDown: typeof import("~icons/cap/chevron-down.jsx")["default"];
+	const IconCapCircle: typeof import("~icons/cap/circle.jsx")["default"];
+	const IconCapCircleCheck: typeof import("~icons/cap/circle-check.jsx")["default"];
+	const IconCapCirclePlus: typeof import("~icons/cap/circle-plus.jsx")["default"];
+	const IconCapCircleX: typeof import("~icons/cap/circle-x.jsx")["default"];
+	const IconCapCopy: typeof import("~icons/cap/copy.jsx")["default"];
+	const IconCapCorners: typeof import("~icons/cap/corners.jsx")["default"];
+	const IconCapCrop: typeof import("~icons/cap/crop.jsx")["default"];
+	const IconCapCursor: typeof import("~icons/cap/cursor.jsx")["default"];
+	const IconCapEditor: typeof import("~icons/cap/editor.jsx")["default"];
+	const IconCapEnlarge: typeof import("~icons/cap/enlarge.jsx")["default"];
+	const IconCapFile: typeof import("~icons/cap/file.jsx")["default"];
+	const IconCapFilmCut: typeof import("~icons/cap/film-cut.jsx")["default"];
+	const IconCapGauge: typeof import("~icons/cap/gauge.jsx")["default"];
+	const IconCapHotkeys: typeof import("~icons/cap/hotkeys.jsx")["default"];
+	const IconCapImage: typeof import("~icons/cap/image.jsx")["default"];
+	const IconCapInfo: typeof import("~icons/cap/info.jsx")["default"];
+	const IconCapInstant: typeof import("~icons/cap/instant.jsx")["default"];
+	const IconCapLayout: typeof import("~icons/cap/layout.jsx")["default"];
+	const IconCapLink: typeof import("~icons/cap/link.jsx")["default"];
+	const IconCapLogo: typeof import("~icons/cap/logo.jsx")["default"];
+	const IconCapLogoFull: typeof import("~icons/cap/logo-full.jsx")["default"];
+	const IconCapLogoFullDark: typeof import("~icons/cap/logo-full-dark.jsx")["default"];
+	const IconCapMessageBubble: typeof import("~icons/cap/message-bubble.jsx")["default"];
+	const IconCapMicrophone: typeof import("~icons/cap/microphone.jsx")["default"];
+	const IconCapMoreVertical: typeof import("~icons/cap/more-vertical.jsx")["default"];
+	const IconCapNext: typeof import("~icons/cap/next.jsx")["default"];
+	const IconCapPadding: typeof import("~icons/cap/padding.jsx")["default"];
+	const IconCapPause: typeof import("~icons/cap/pause.jsx")["default"];
+	const IconCapPauseCircle: typeof import("~icons/cap/pause-circle.jsx")["default"];
+	const IconCapPlay: typeof import("~icons/cap/play.jsx")["default"];
+	const IconCapPlayCircle: typeof import("~icons/cap/play-circle.jsx")["default"];
+	const IconCapPresets: typeof import("~icons/cap/presets.jsx")["default"];
+	const IconCapPrev: typeof import("~icons/cap/prev.jsx")["default"];
+	const IconCapRedo: typeof import("~icons/cap/redo.jsx")["default"];
+	const IconCapRestart: typeof import("~icons/cap/restart.jsx")["default"];
+	const IconCapScissors: typeof import("~icons/cap/scissors.jsx")["default"];
+	const IconCapSettings: typeof import("~icons/cap/settings.jsx")["default"];
+	const IconCapShadow: typeof import("~icons/cap/shadow.jsx")["default"];
+	const IconCapSquare: typeof import("~icons/cap/square.jsx")["default"];
+	const IconCapStopCircle: typeof import("~icons/cap/stop-circle.jsx")["default"];
+	const IconCapTrash: typeof import("~icons/cap/trash.jsx")["default"];
+	const IconCapUndo: typeof import("~icons/cap/undo.jsx")["default"];
+	const IconCapUpload: typeof import("~icons/cap/upload.jsx")["default"];
+	const IconCapZoomIn: typeof import("~icons/cap/zoom-in.jsx")["default"];
+	const IconCapZoomOut: typeof import("~icons/cap/zoom-out.jsx")["default"];
+	const IconHugeiconsEaseCurveControlPoints: typeof import("~icons/hugeicons/ease-curve-control-points.jsx")["default"];
+	const IconLucideAppWindowMac: typeof import("~icons/lucide/app-window-mac.jsx")["default"];
+	const IconLucideBell: typeof import("~icons/lucide/bell.jsx")["default"];
+	const IconLucideBug: typeof import("~icons/lucide/bug.jsx")["default"];
+	const IconLucideCheck: typeof import("~icons/lucide/check.jsx")["default"];
+	const IconLucideClock: typeof import("~icons/lucide/clock.jsx")["default"];
+	const IconLucideDatabase: typeof import("~icons/lucide/database.jsx")["default"];
+	const IconLucideEdit: typeof import("~icons/lucide/edit.jsx")["default"];
+	const IconLucideEye: typeof import("~icons/lucide/eye.jsx")["default"];
+	const IconLucideEyeOff: typeof import("~icons/lucide/eye-off.jsx")["default"];
+	const IconLucideFolder: typeof import("~icons/lucide/folder.jsx")["default"];
+	const IconLucideGift: typeof import("~icons/lucide/gift.jsx")["default"];
+	const IconLucideHardDrive: typeof import("~icons/lucide/hard-drive.jsx")["default"];
+	const IconLucideLayout: typeof import("~icons/lucide/layout.jsx")["default"];
+	const IconLucideLoaderCircle: typeof import("~icons/lucide/loader-circle.jsx")["default"];
+	const IconLucideMessageSquarePlus: typeof import("~icons/lucide/message-square-plus.jsx")["default"];
+	const IconLucideMicOff: typeof import("~icons/lucide/mic-off.jsx")["default"];
+	const IconLucideMonitor: typeof import("~icons/lucide/monitor.jsx")["default"];
+	const IconLucideRectangleHorizontal: typeof import("~icons/lucide/rectangle-horizontal.jsx")["default"];
+	const IconLucideRotateCcw: typeof import("~icons/lucide/rotate-ccw.jsx")["default"];
+	const IconLucideSearch: typeof import("~icons/lucide/search.jsx")["default"];
+	const IconLucideSquarePlay: typeof import("~icons/lucide/square-play.jsx")["default"];
+	const IconLucideUnplug: typeof import("~icons/lucide/unplug.jsx")["default"];
+	const IconLucideVolume2: typeof import("~icons/lucide/volume2.jsx")["default"];
+	const IconLucideVolumeX: typeof import("~icons/lucide/volume-x.jsx")["default"];
+	const IconMaterialSymbolsScreenshotFrame2Rounded: typeof import("~icons/material-symbols/screenshot-frame2-rounded.jsx")["default"];
+	const IconMdiMonitor: typeof import("~icons/mdi/monitor.jsx")["default"];
+	const IconPhMonitorBold: typeof import("~icons/ph/monitor-bold.jsx")["default"];
 }

From 058f7d812ef5f618c495f11a5beaf67d6245df45 Mon Sep 17 00:00:00 2001
From: Brendan Allan <brendonovich@outlook.com>
Date: Mon, 25 Aug 2025 19:46:46 +0800
Subject: [PATCH 7/7] don't hold app state while setting mic input

---
 apps/desktop/src-tauri/src/lib.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/apps/desktop/src-tauri/src/lib.rs b/apps/desktop/src-tauri/src/lib.rs
index 716e5dbdf6..38c15d50ea 100644
--- a/apps/desktop/src-tauri/src/lib.rs
+++ b/apps/desktop/src-tauri/src/lib.rs
@@ -217,17 +217,17 @@ impl App {
 #[tauri::command]
 #[specta::specta]
 async fn set_mic_input(state: MutableState<'_, App>, label: Option<String>) -> Result<(), String> {
-    let app = state.write().await;
+    let mic_feed = state.read().await.mic_feed.clone();
 
     match label {
         None => {
-            app.mic_feed
+            mic_feed
                 .ask(microphone::RemoveInput)
                 .await
                 .map_err(|e| e.to_string())?;
         }
         Some(label) => {
-            app.mic_feed
+            mic_feed
                 .ask(feeds::microphone::SetInput { label })
                 .await
                 .map_err(|e| e.to_string())?