`livekit` includes a `webrtc` crate, which builds V8. Its inclusion results in
some absurdly long paths, which are blowing out Vite's watcher process. My
initial fix tried to just enable long paths on Windows, but that did not
solve the issue. This was the second best alternative, but it's not very
cross-platform.

@@ -32,0 +38,4 @@
+    /// `Sized`, so all dasp adapters (`.map()`, `.scale_amp()`, rate
+    /// converters, etc.) work on it directly.
+    #[instrument(skip(self))]
+    pub async fn get_signal(&self) -> Result<(BoxedSignal<i16>, u32), AudioDeviceError> {

@@ -127,3 +131,4 @@
+            sample_rate,
         })
     }
 

@@ -0,0 +31,4 @@
+}
+
+// SAFETY: The inner Box holds a `Send` trait object.
+unsafe impl<F> Send for BoxedSignal<F> {}

@@ -0,0 +85,4 @@
+}
+
+// SAFETY: Receiver<Vec<f32>> is Send.
+unsafe impl Send for ReceiverSignal {}

@@ -0,0 +45,4 @@
+impl ChannelsManager {
+    #[instrument(name = "channels_manager_new", skip(config))]
+    pub fn new(config: ConfigManager) -> Arc<Self> {
+        let manager = Arc::new(ChannelsManager {

@@ -0,0 +181,4 @@
+        let room_arc = self.room.clone();
+        let output_rate = output.lock().await.sample_rate();
+        let output_for_events = output.clone();
+        let events_handle = tauri::async_runtime::spawn(async move {

@@ -0,0 +235,4 @@
+        // Spawn the mic capture pipeline:
+        //   blocking thread → reads dasp signal, batches into 10 ms frames
+        //   async task      → receives frames, calls source.capture_frame()
+        let samples_per_channel = (sample_rate / 100) as usize; // 10 ms

@@ -0,0 +1,19 @@
+use tracing::instrument;

@@ -0,0 +1,53 @@
+use std::sync::Arc;

@@ -22,1 +28,4 @@
         .setup(|app| {
+            setup_tracing();
+
+            let _guard = info_span!("setting up managers").entered();

@@ -1,17 +1,15 @@
-use std::sync::Arc;

@@ -79,0 +25,4 @@
+    }
+
+    // Start the input stream and obtain a live i16 signal.
+    let crate::audio::input::CapturedAudio {

@@ -0,0 +38,4 @@
+/// construction — `dasp::signal::from_iter` calls `iter.next()` immediately on
+/// construction, which would block for a blocking iterator.
+pub struct ReceiverSignal {
+    rx: mpsc::Receiver<Vec<f32>>,

@@ -0,0 +44,4 @@
+}
+
+impl ReceiverSignal {
+    pub fn new(rx: mpsc::Receiver<Vec<f32>>) -> Self {

@@ -0,0 +68,4 @@
+                self.current = batch.into_iter();
+                self.current.next().unwrap_or(0.0)
+            }
+            Err(mpsc::TryRecvError::Empty) => 0.0,

@@ -0,0 +36,4 @@
+    audio: State<'_, AudioManager>,
+    channel_id: String,
+) -> Result<(), String> {
+    let crate::audio::input::CapturedAudio {

@@ -0,0 +75,4 @@
+        let manager = Arc::clone(&self);
+        let config = self.config.clone();
+
+        tauri::async_runtime::spawn(handle_config_changes(config, manager));

@@ -0,0 +192,4 @@
+        }
+
+        // Spawn the room-events task with track subscription handling.
+        let events_handle = tauri::async_runtime::spawn(handle_room_events(

@@ -0,0 +211,4 @@
+        //   async task      → receives frames, calls source.capture_frame()
+        let samples_per_channel = (sample_rate / (1000 / FRAME_DURATION_MS)) as usize;
+        let (frame_tx, mut frame_rx) =
+            tokio::sync::mpsc::channel::<Vec<i16>>(MIC_FRAME_CHANNEL_CAPACITY);

@@ -0,0 +220,4 @@
+                buf.push(signal.next());
+                if buf.len() >= samples_per_channel {
+                    let batch =
+                        std::mem::replace(&mut buf, Vec::with_capacity(samples_per_channel));

@@ -0,0 +340,4 @@
+    output: &Arc<Mutex<OutputDeviceManager>>,
+) -> Option<(JoinHandle<()>, StreamHandle)> {
+    let mut stream = NativeAudioStream::new(track.rtc_track(), sample_rate as i32, MONO_CHANNEL_COUNT as i32);
+    let (tx, rx) = std::sync::mpsc::channel::<Vec<f32>>();