merge queue: checking #7919 on main (b89f9f6)

packages/app-lib/src/api/friends.rs

@@ -12,7 +12,7 @@ pub async fn friends() -> crate::Result<Vec<UserFriend>> {
 
 pub async fn friend_statuses() -> crate::Result<Vec<UserStatus>> {
     let state = crate::State::get().await?;
-    let statuses = state.friends_socket.friend_statuses();
+    let statuses = state.presence.friends_socket.friend_statuses();
 
     Ok(statuses)
 }

packages/app-lib/src/api/instance/files.rs

@@ -192,7 +192,7 @@ pub async fn write_instance_file(
     create_only: bool,
 ) -> crate::Result<()> {
     let state = State::get().await?;
-    let _instance = state.lock_instance_content(instance_id).await;
+    let _instance = state.instance_locks.lock_content(instance_id).await;
     let _files = state.content_store.files_lock.lock().await;
     let destination = resolve(&state, instance_id, path, true)
         .await?
@@ -238,7 +238,7 @@ pub async fn create_instance_directory(
     path: &str,
 ) -> crate::Result<()> {
     let state = State::get().await?;
-    let _instance = state.lock_instance_content(instance_id).await;
+    let _instance = state.instance_locks.lock_content(instance_id).await;
     let _files = state.content_store.files_lock.lock().await;
     let destination = resolve(&state, instance_id, path, true).await?;
     fs::create_dir(destination.path()).await?;
@@ -251,7 +251,7 @@ pub async fn rename_instance_file(
     destination: &str,
 ) -> crate::Result<()> {
     let state = State::get().await?;
-    let _instance = state.lock_instance_content(instance_id).await;
+    let _instance = state.instance_locks.lock_content(instance_id).await;
     let _files = state.content_store.files_lock.lock().await;
     let source = resolve(&state, instance_id, source, true).await?;
     let destination = resolve(&state, instance_id, destination, true).await?;
@@ -270,7 +270,7 @@ pub async fn delete_instance_file(
     recursive: bool,
 ) -> crate::Result<()> {
     let state = State::get().await?;
-    let _instance = state.lock_instance_content(instance_id).await;
+    let _instance = state.instance_locks.lock_content(instance_id).await;
     let _files = state.content_store.files_lock.lock().await;
     let path = resolve(&state, instance_id, path, true).await?;
     if fs::symlink_metadata(path.path()).await?.is_dir() {

packages/app-lib/src/api/instance/screenshots/operations.rs

@@ -18,6 +18,7 @@ use crate::state::instances::adapters::sqlite::{
     instance_rows::{self, InstanceScreenshotSource},
     screenshot_rows,
 };
+use crate::state::{DirectoryInfo, InstanceLocks};
 use crate::util::fetch::sha1_file_async;
 use crate::util::io::{self, IOError};
 use crate::{ErrorKind, State};
@@ -103,12 +104,12 @@ async fn list_source_screenshot_sets(
 }
 
 async fn lock_instance_screenshots<'a>(
-    state: &State,
+    instance_locks: &InstanceLocks,
     instance_ids: impl IntoIterator<Item = &'a str>,
 ) -> Vec<OwnedMutexGuard<()>> {
     let mut locks = Vec::new();
     for instance_id in instance_ids {
-        locks.push(state.lock_instance_screenshots(instance_id).await);
+        locks.push(instance_locks.lock_screenshots(instance_id).await);
     }
     locks
 }
@@ -122,7 +123,8 @@ pub async fn delete_screenshots(keys: &[ScreenshotKey]) -> crate::Result<()> {
         .collect::<Vec<_>>();
     instance_ids.sort_unstable();
     instance_ids.dedup();
-    let _locks = lock_instance_screenshots(&state, instance_ids).await;
+    let _locks =
+        lock_instance_screenshots(&state.instance_locks, instance_ids).await;
 
     for key in keys {
         io::remove_file(get_screenshot_path(key).await?).await?;
@@ -224,14 +226,16 @@ pub async fn move_screenshots(
         .collect::<Vec<_>>();
     instance_ids.sort_unstable();
     instance_ids.dedup();
-    let _locks = lock_instance_screenshots(&state, instance_ids).await;
+    let _locks =
+        lock_instance_screenshots(&state.instance_locks, instance_ids).await;
     let target_source = instance_rows::get_instance_screenshot_source(
         target_instance_id,
         &state.pool,
     )
     .await?
     .ok_or(ErrorKind::InputError("unknown target instance".to_string()))?;
-    let target_dir = source_screenshots_dir(&state, &target_source).await?;
+    let target_dir =
+        source_screenshots_dir(&state.directories, &target_source).await?;
     io::create_dir_all(&target_dir).await?;
     ensure_directory_is_not_symlink(&target_dir).await?;
 
@@ -285,7 +289,8 @@ pub async fn get_screenshot_path(
     )
     .await?
     .ok_or(ErrorKind::InputError("unknown instance".to_string()))?;
-    let screenshots_dir = source_screenshots_dir(&state, &source).await?;
+    let screenshots_dir =
+        source_screenshots_dir(&state.directories, &source).await?;
     let canonical_dir = tokio::fs::canonicalize(&screenshots_dir)
         .await
         .map_err(|error| IOError::with_path(error, &screenshots_dir))?;
@@ -327,9 +332,9 @@ pub async fn save_edited_screenshot(
     )
     .await?
     .ok_or(ErrorKind::InputError("unknown instance".to_string()))?;
-    let _lock = state.lock_instance_screenshots(&source.id).await;
+    let _lock = state.instance_locks.lock_screenshots(&source.id).await;
 
-    let scanned = scan_source_screenshots(&state, &source).await?;
+    let scanned = scan_source_screenshots(&state.directories, &source).await?;
     let current =
         reconcile_source_screenshots(&state, &source, scanned).await?;
     let source_screenshot = current
@@ -374,7 +379,8 @@ pub async fn save_edited_screenshot(
         )));
     }
 
-    let screenshots_dir = source_screenshots_dir(&state, &source).await?;
+    let screenshots_dir =
+        source_screenshots_dir(&state.directories, &source).await?;
     let (target_path, copy_group) = match mode {
         ScreenshotEditSaveMode::CreateCopy => (
             available_target_path(&screenshots_dir, &source_row.file_name)
@@ -407,7 +413,7 @@ pub async fn save_edited_screenshot(
         screenshot_rows::update_screenshot(&source_row, &mut tx).await?;
         tx.commit().await?;
     }
-    let scanned = scan_source_screenshots(&state, &source).await?;
+    let scanned = scan_source_screenshots(&state.directories, &source).await?;
     let reconciled =
         reconcile_source_screenshots(&state, &source, scanned).await?;
     let mut saved = reconciled
@@ -478,10 +484,10 @@ pub async fn save_edited_screenshot(
 }
 
 pub(super) async fn source_screenshots_dir(
-    state: &State,
+    directories: &DirectoryInfo,
     source: &InstanceScreenshotSource,
 ) -> crate::Result<PathBuf> {
-    let instance_dir = state.directories.instances_dir().join(&source.path);
+    let instance_dir = directories.instances_dir().join(&source.path);
     let canonical_instance_dir =
         tokio::fs::canonicalize(&instance_dir)
             .await

packages/app-lib/src/api/instance/screenshots/reconciliation.rs

@@ -2,6 +2,7 @@ use super::operations::{
     InstanceScreenshot, has_png_extension, sort_screenshots,
     source_screenshots_dir,
 };
+use crate::state::DirectoryInfo;
 use crate::state::instances::adapters::sqlite::{
     instance_rows::{self, InstanceScreenshotSource},
     screenshot_rows::{self, ScreenshotRow},
@@ -80,8 +81,8 @@ pub(super) async fn list_source_screenshots(
     state: &State,
     source: InstanceScreenshotSource,
 ) -> crate::Result<Vec<InstanceScreenshot>> {
-    let _lock = state.lock_instance_screenshots(&source.id).await;
-    let scanned = scan_source_screenshots(state, &source).await?;
+    let _lock = state.instance_locks.lock_screenshots(&source.id).await;
+    let scanned = scan_source_screenshots(&state.directories, &source).await?;
     reconcile_source_screenshots(state, &source, scanned).await
 }
 
@@ -101,18 +102,18 @@ pub(crate) async fn reconcile_screenshots(
 }
 
 pub(super) async fn scan_source_screenshots(
-    state: &State,
+    directories: &DirectoryInfo,
     source: &InstanceScreenshotSource,
 ) -> crate::Result<Vec<ScannedScreenshot>> {
-    let instance_dir = state.directories.instances_dir().join(&source.path);
+    let instance_dir = directories.instances_dir().join(&source.path);
     if !tokio::fs::try_exists(&instance_dir)
         .await
         .map_err(|error| IOError::with_path(error, &instance_dir))?
     {
         return Ok(Vec::new());
     }
 
-    let screenshots_dir = source_screenshots_dir(state, source).await?;
+    let screenshots_dir = source_screenshots_dir(directories, source).await?;
     tokio::task::spawn_blocking(move || scan_screenshots_dir(&screenshots_dir))
         .await?
 }

packages/app-lib/src/api/instance/shared/invites.rs

@@ -25,7 +25,8 @@ pub async fn invite_shared_instance_users(
     user_ids: Vec<String>,
 ) -> crate::Result<SharedInstanceUsers> {
     let state = State::get().await?;
-    let _shared_instance_lock = state.lock_shared_instance(instance_id).await;
+    let _shared_instance_lock =
+        state.instance_locks.lock_shared(instance_id).await;
     let (metadata, attachment) =
         shared_instance_for_invites(instance_id, user_ids.len(), &state)
             .await?;
@@ -65,7 +66,8 @@ pub async fn create_shared_instance_invite_link(
     replace_invite_id: Option<String>,
 ) -> crate::Result<SharedInstanceInviteLink> {
     let state = State::get().await?;
-    let _shared_instance_lock = state.lock_shared_instance(instance_id).await;
+    let _shared_instance_lock =
+        state.instance_locks.lock_shared(instance_id).await;
     let (metadata, attachment) =
         shared_instance_for_invites(instance_id, 0, &state).await?;
     ensure_owner(&attachment)?;
@@ -150,7 +152,8 @@ pub async fn revoke_shared_instance_invite(
     invite_id: String,
 ) -> crate::Result<()> {
     let state = State::get().await?;
-    let _shared_instance_lock = state.lock_shared_instance(instance_id).await;
+    let _shared_instance_lock =
+        state.instance_locks.lock_shared(instance_id).await;
     let Some(attachment) = shared_attachment(instance_id, &state).await? else {
         return Ok(());
     };
@@ -167,7 +170,8 @@ pub async fn remove_shared_instance_users(
     has_pending_recipients: bool,
 ) -> crate::Result<SharedInstanceUsers> {
     let state = State::get().await?;
-    let _shared_instance_lock = state.lock_shared_instance(instance_id).await;
+    let _shared_instance_lock =
+        state.instance_locks.lock_shared(instance_id).await;
     let Some(attachment) = shared_attachment(instance_id, &state).await? else {
         return Ok(SharedInstanceUsers::empty());
     };

packages/app-lib/src/api/instance/synced_options/command_history.rs

@@ -15,7 +15,7 @@ const COMMAND_HISTORY_LIMIT: usize = 50;
 
 pub async fn get_command_history() -> crate::Result<String> {
     let state = State::get().await?;
-    let _guard = state.lock_synced_options().await;
+    let _guard = state.synced_options.lock().await;
     let path = command_history_path(&state);
     if !path.exists() {
         return Ok(String::new());
@@ -25,7 +25,7 @@ pub async fn get_command_history() -> crate::Result<String> {
 
 pub async fn set_command_history(contents: &str) -> crate::Result<String> {
     let state = State::get().await?;
-    let _guard = state.lock_synced_options().await;
+    let _guard = state.synced_options.lock().await;
     create_synced_directories(&state).await?;
     let normalized = normalize_command_history(contents);
     io::write(command_history_path(&state), normalized.as_bytes()).await?;

packages/app-lib/src/api/instance/synced_options/game_options/launch_overrides.rs

@@ -26,7 +26,7 @@ pub(super) fn currently_launcher_owned_keys(
 /// Writes canonical settings to `options.txt` before launch.
 pub async fn sync_before_launch(instance_id: &str) -> crate::Result<()> {
     let state = State::get().await?;
-    let _guard = state.lock_synced_options().await;
+    let _guard = state.synced_options.lock().await;
     let metadata = crate::state::get_instance(instance_id, &state.pool)
         .await?
         .ok_or(ErrorKind::InputError("unknown instance".to_string()))?;
@@ -48,7 +48,7 @@ pub async fn apply_launcher_overrides(
         return Ok(());
     }
     let state = State::get().await?;
-    let _guard = state.lock_synced_options().await;
+    let _guard = state.synced_options.lock().await;
     let metadata = crate::state::get_instance(instance_id, &state.pool)
         .await?
         .ok_or(ErrorKind::InputError("unknown instance".to_string()))?;

packages/app-lib/src/api/instance/synced_options/game_options/local_settings_editor.rs

@@ -266,7 +266,7 @@ pub async fn get_config(
     instance_id: &str,
 ) -> crate::Result<GameSettingsEditorState> {
     let state = State::get().await?;
-    let _guard = state.lock_synced_options().await;
+    let _guard = state.synced_options.lock().await;
     load_editor(instance_id, &state).await
 }
 
@@ -275,7 +275,7 @@ pub async fn preview_changes(
     request: UpdateGameSettingsRequest,
 ) -> crate::Result<GameSettingsEditorState> {
     let state = State::get().await?;
-    let _guard = state.lock_synced_options().await;
+    let _guard = state.synced_options.lock().await;
     let (metadata, document, input_bytes, controlled_keys) =
         load_instance_document(instance_id, &state).await?;
     let mut editor = build_editor_state(
@@ -335,7 +335,7 @@ pub async fn save_changes(
     request: UpdateGameSettingsRequest,
 ) -> crate::Result<SaveGameSettingsResult> {
     let state = State::get().await?;
-    let _guard = state.lock_synced_options().await;
+    let _guard = state.synced_options.lock().await;
     let (metadata, mut document, input_bytes, controlled_keys) =
         load_instance_document(instance_id, &state).await?;
     let current_editor = build_editor_state(

packages/app-lib/src/api/instance/synced_options/game_options/locales/mod.rs

@@ -80,7 +80,7 @@ struct Candidate {
 
 pub(crate) fn queue_game_locale_index() {
     if let Some(state) = State::get_if_initialized() {
-        state.game_locale_indexer.notify.notify_one();
+        state.synced_options.locales.notify.notify_one();
     } else {
         tracing::warn!(
             "Game setting locales: cannot queue indexing before state initialization"
@@ -90,16 +90,17 @@ pub(crate) fn queue_game_locale_index() {
 
 pub(crate) fn start_game_locale_indexer(state: Arc<State>) {
     if state
-        .game_locale_indexer
+        .synced_options
+        .locales
         .started
         .swap(true, Ordering::AcqRel)
     {
         return;
     }
-    state.game_locale_indexer.notify.notify_one();
+    state.synced_options.locales.notify.notify_one();
     tokio::spawn(async move {
         loop {
-            state.game_locale_indexer.notify.notified().await;
+            state.synced_options.locales.notify.notified().await;
             tokio::time::sleep(std::time::Duration::from_millis(300)).await;
             if let Err(error) = index_installed_sources(&state).await {
                 tracing::warn!(%error, "Game setting locales: indexing failed");

packages/app-lib/src/api/instance/synced_options/game_options/pack_updates.rs

@@ -293,7 +293,7 @@ pub async fn capture_pack_base(
     source: Option<GameOptionsPackSource>,
 ) -> crate::Result<()> {
     let state = State::get().await?;
-    let _guard = state.lock_synced_options().await;
+    let _guard = state.synced_options.lock().await;
     let metadata = crate::state::get_instance(instance_id, &state.pool)
         .await?
         .ok_or(crate::ErrorKind::InputError("unknown instance".to_string()))?;

packages/app-lib/src/api/instance/synced_options/game_options/settings_editor.rs

@@ -195,7 +195,7 @@ pub(super) async fn load_settings_editor(
 
 pub async fn get_config() -> crate::Result<GameSettingsEditorState> {
     let state = State::get().await?;
-    let _guard = state.lock_synced_options().await;
+    let _guard = state.synced_options.lock().await;
     load_settings_editor(&state).await
 }
 
@@ -204,7 +204,7 @@ pub async fn preview_changes(
     request: UpdateGameSettingsRequest,
 ) -> crate::Result<GameSettingsEditorState> {
     let state = State::get().await?;
-    let _guard = state.lock_synced_options().await;
+    let _guard = state.synced_options.lock().await;
     if request.expected_catalog_revision != CATALOG_REVISION {
         return load_settings_editor(&state).await;
     }
@@ -277,7 +277,7 @@ pub async fn save_changes(
     request: UpdateGameSettingsRequest,
 ) -> crate::Result<SaveGameSettingsResult> {
     let state = State::get().await?;
-    let _guard = state.lock_synced_options().await;
+    let _guard = state.synced_options.lock().await;
     if !game_options_sync_is_enabled(&state.pool).await? {
         bail!(ErrorKind::InputError(
             "turn on game-settings sync before editing shared values"

packages/app-lib/src/api/instance/synced_options/game_options/source_selection.rs

@@ -323,7 +323,7 @@ pub(in crate::api::instance) async fn initialize_from_source_instance(
 pub async fn list_sync_sources()
 -> crate::Result<Vec<GameOptionsSourceCandidate>> {
     let state = State::get().await?;
-    let _guard = state.lock_synced_options().await;
+    let _guard = state.synced_options.lock().await;
     let instances = crate::state::list_instances(&state.pool).await?;
     let mut sources = Vec::with_capacity(instances.len());
     for metadata in instances {