feat: Various features + performance bits

apps/desktop/src-tauri/src/recording.rs

@@ -31,6 +31,7 @@
     any::Any,
     collections::{HashMap, VecDeque},
     error::Error as StdError,
+    mem,
     panic::AssertUnwindSafe,
     path::{Path, PathBuf},
     str::FromStr,
@@ -64,6 +65,8 @@
     web_api::ManagerExt,
     windows::{CapWindowId, ShowCapWindow},
 };
+#[cfg(target_os = "macos")]
+use scap_targets::Window;
 
 #[derive(Clone)]
 pub struct InProgressRecordingCommon {
@@ -107,6 +110,7 @@
 #[cfg(target_os = "macos")]
 async fn acquire_shareable_content_for_target(
     capture_target: &ScreenCaptureTarget,
+    excluded_windows: &[scap_targets::WindowId],
 ) -> anyhow::Result<SendableShareableContent> {
     let mut refreshed = false;
 
@@ -118,13 +122,20 @@
                 .ok_or_else(|| anyhow!("GetShareableContent/NotAvailable"))?,
         );
 
-        if !shareable_content_missing_target_display(capture_target, shareable_content.retained())
-            .await
-        {
+        let sc_content = shareable_content.retained();
+        let missing_display =
+            shareable_content_missing_target_display(capture_target, sc_content.clone()).await;
+        let missing_windows =
+            shareable_content_missing_windows(excluded_windows, sc_content.clone()).await;
+
+        if !missing_display && (!missing_windows || refreshed) {
+            if missing_windows && refreshed {
+                debug!("Excluded windows missing from refreshed ScreenCaptureKit content");
+            }
             return Ok(shareable_content);
         }
 
-        if refreshed {
+        if refreshed && missing_display {
             return Err(anyhow!("GetShareableContent/DisplayMissing"));
         }
 
@@ -150,6 +161,74 @@
     }
 }
 
+#[cfg(target_os = "macos")]
+async fn shareable_content_missing_windows(
+    excluded_windows: &[scap_targets::WindowId],
+    shareable_content: cidre::arc::R<cidre::sc::ShareableContent>,
+) -> bool {
+    if excluded_windows.is_empty() {
+        return false;
+    }
+
+    for window_id in excluded_windows {
+        let Some(window) = Window::from_id(window_id) else {
+            continue;
+        };
+
+        if window
+            .raw_handle()
+            .as_sc(shareable_content.clone())
+            .await
+            .is_none()
+        {
+            return true;
+        }
+    }
+
+    false
+}
+
+#[cfg(target_os = "macos")]
+async fn prune_excluded_windows_without_shareable_content(
+    excluded_windows: &mut Vec<scap_targets::WindowId>,
+    shareable_content: cidre::arc::R<cidre::sc::ShareableContent>,
+) {
+    if excluded_windows.is_empty() {
+        return;
+    }
+
+    let mut removed = 0usize;
+    let mut pruned = Vec::with_capacity(excluded_windows.len());
+    let current = mem::take(excluded_windows);
+
+    for window_id in current {
+        let Some(window) = Window::from_id(&window_id) else {
+            removed += 1;
+            continue;
+        };
+
+        if window
+            .raw_handle()
+            .as_sc(shareable_content.clone())
+            .await
+            .is_some()
+        {
+            pruned.push(window_id);
+        } else {
+            removed += 1;
+        }
+    }
+
+    if removed > 0 {
+        debug!(
+            removed,
+            "Dropping excluded windows missing from ScreenCaptureKit content"
+        );
+    }
+
+    *excluded_windows = pruned;
+}
+
 #[cfg(target_os = "macos")]
 fn is_shareable_content_error(err: &anyhow::Error) -> bool {
     err.chain().any(|cause| {
@@ -372,17 +451,17 @@
     };
 
     if let Some(mic) = settings.mic_name.clone().filter(|_| needs_mic) {
         match apply_mic_input(app.state(), Some(mic)).await {
             Err(err) => warn!(%err, "Failed to restore microphone input"),
             Ok(_) => {}
         }
     }
 
     if let Some(camera) = settings.camera_id.clone().filter(|_| needs_camera) {
         match apply_camera_input(app.clone(), app.state(), Some(camera)).await {
             Err(err) => warn!(%err, "Failed to restore camera input"),
             Ok(_) => {}
         }
     }
 }
 
@@ -613,17 +692,7 @@
             state.camera_in_use = camera_feed.is_some();
 
             #[cfg(target_os = "macos")]
-            let mut shareable_content =
-                acquire_shareable_content_for_target(&inputs.capture_target).await?;
-
-            let common = InProgressRecordingCommon {
-                target_name,
-                inputs: inputs.clone(),
-                recording_dir: recording_dir.clone(),
-            };
-
-            #[cfg(target_os = "macos")]
-            let excluded_windows = {
+            let mut excluded_windows = {
                 let window_exclusions = general_settings
                     .as_ref()
                     .map_or_else(general_settings::default_excluded_windows, |settings| {
@@ -633,6 +702,24 @@
                 crate::window_exclusion::resolve_window_ids(&window_exclusions)
             };
 
+            #[cfg(target_os = "macos")]
+            let mut shareable_content =
+                acquire_shareable_content_for_target(&inputs.capture_target, &excluded_windows)
+                    .await?;
+
+            #[cfg(target_os = "macos")]
+            prune_excluded_windows_without_shareable_content(
+                &mut excluded_windows,
+                shareable_content.retained(),
+            )
+            .await;
+
+            let common = InProgressRecordingCommon {
+                target_name,
+                inputs: inputs.clone(),
+                recording_dir: recording_dir.clone(),
+            };
+
             let mut mic_restart_attempts = 0;
 
             let done_fut = loop {
@@ -751,8 +838,16 @@
                     }
                     #[cfg(target_os = "macos")]
                     Err(err) if is_shareable_content_error(&err) => {
-                        shareable_content =
-                            acquire_shareable_content_for_target(&inputs.capture_target).await?;
+                        shareable_content = acquire_shareable_content_for_target(
+                            &inputs.capture_target,
+                            &excluded_windows,
+                        )
+                        .await?;
+                        prune_excluded_windows_without_shareable_content(
+                            &mut excluded_windows,
+                            shareable_content.retained(),
+                        )
+                        .await;
                         continue;
                     }
                     Err(err) if mic_restart_attempts == 0 && mic_actor_not_running(&err) => {

apps/desktop/src/routes/editor/context.ts

@@ -6,7 +6,6 @@ import { createContextProvider } from "@solid-primitives/context";
 import { trackStore } from "@solid-primitives/deep";
 import { createEventListener } from "@solid-primitives/event-listener";
 import { createUndoHistory } from "@solid-primitives/history";
-import { debounce } from "@solid-primitives/scheduled";
 import { createQuery, skipToken } from "@tanstack/solid-query";
 import {
 	type Accessor,
@@ -15,6 +14,7 @@ import {
 	createResource,
 	createSignal,
 	on,
+	onCleanup,
 } from "solid-js";
 import { createStore, produce, reconcile, unwrap } from "solid-js/store";
 
@@ -51,6 +51,7 @@ export const OUTPUT_SIZE = {
 };
 
 export const MAX_ZOOM_IN = 3;
+const PROJECT_SAVE_DEBOUNCE_MS = 250;
 
 export type RenderState =
 	| { type: "starting" }
@@ -295,14 +296,62 @@ export const [EditorContextProvider, useEditorContext] = createContextProvider(
 			},
 		};
 
+		let projectSaveTimeout: number | undefined;
+		let saveInFlight = false;
+		let shouldResave = false;
+		let hasPendingProjectSave = false;
+
+		const flushProjectConfig = async () => {
+			if (!hasPendingProjectSave && !saveInFlight) return;
+			if (saveInFlight) {
+				if (hasPendingProjectSave) {
+					shouldResave = true;
+				}
+				return;
+			}
+			saveInFlight = true;
+			shouldResave = false;
+			hasPendingProjectSave = false;
+			try {
+				await commands.setProjectConfig(serializeProjectConfiguration(project));
+			} catch (error) {
+				console.error("Failed to persist project config", error);
+			} finally {
+				saveInFlight = false;
+				if (shouldResave) {
+					shouldResave = false;
+					void flushProjectConfig();
+				}
+			}
+		};
+
+		const scheduleProjectConfigSave = () => {
+			hasPendingProjectSave = true;
+			if (projectSaveTimeout) {
+				clearTimeout(projectSaveTimeout);
+			}
+			projectSaveTimeout = window.setTimeout(() => {
+				projectSaveTimeout = undefined;
+				void flushProjectConfig();
+			}, PROJECT_SAVE_DEBOUNCE_MS);
+		};
+
+		onCleanup(() => {
+			if (projectSaveTimeout) {
+				clearTimeout(projectSaveTimeout);
+				projectSaveTimeout = undefined;
+			}
+			void flushProjectConfig();
+		});
+
 		createEffect(
 			on(
 				() => {
 					trackStore(project);
 				},
-				debounce(() => {
-					commands.setProjectConfig(serializeProjectConfiguration(project));
-				}),
+				() => {
+					scheduleProjectConfigSave();
+				},
 				{ defer: true },
 			),
 		);