Bugfix: upsert in notify_added so post-write size wins the watcher race

After the previous commit, the SMB watcher and `write_from_stream`'s `notify_mutation` both stat the file and call `notify_directory_changed(Added(entry))`. The watcher's stat fires mid-write and catches a partial size; `write_from_stream`'s fires post-close and gets the final size. `notify_added` used `insert_entry_sorted`, which silently early-returns on duplicate path — so whichever Added landed in the cache first stuck, and the second observation was dropped. Result on MTP→SMB: 3 of 9 files copied with the correct bytes on disk but a cached size frozen at the partial mid-write value, visible in the FE until the user navigated away and back. Confirmed in the log: msg_id 266-269 stat returned `size=2359284` at T+213 ms (file still streaming); msg_id 313+ stat at T+330 ms returned 4989168 (post-Close) but was silently dropped because the path already had an entry.

Fix: `notify_added` now upserts. If `has_entry(listing_id, path)` is true, it routes to `notify_modified` (which updates the entry and emits the right diff type to the FE). Otherwise the existing insert path runs. The semantic — "this entry exists with this state at this point in time" — is the same; the cache now reflects the latest observation rather than the first.

Pinned by `notify_added_upserts_when_entry_already_present` in `caching_test.rs`: two Added calls with the same path and different sizes — final cache must hold the second size. TDD-verified red before the upsert: assertion failed with exactly the partial-size left-over (`Some(2359284)` vs expected `Some(4989168)`).

`notify_added` exposed as `pub(super)` so the test can drive it directly.

Author: vdavid

apps/desktop/src-tauri/src/file_system/listing/caching.rs

@@ -337,12 +337,28 @@ pub fn notify_directory_changed(volume_id: &str, parent_path: &Path, change: Dir
 
 /// Inserts an entry into the cache and queues a single-add change for the next
 /// coalesced `directory-diff` flush.
-fn notify_added(listing_id: &str, entry: FileEntry) {
+///
+/// **Upsert semantics**: if a cached entry with the same path already exists,
+/// delegates to `notify_modified` so the cache reflects the latest observation
+/// instead of dropping it. This matters when the SMB / MTP watcher fires an
+/// Add event mid-write (the watcher's stat catches a partial file size), then
+/// `Volume::write_from_stream` fires its own Add post-close with the final
+/// size. Without upsert, the partial size from the watcher sticks and the FE
+/// shows a wrong size until the next manual refresh. Concretely seen on
+/// MTP→SMB copies: 9 files copied, 3 stuck at half size (watcher stat'd
+/// mid-write, self-notify lost the race against `insert_entry_sorted`'s
+/// duplicate guard).
+pub(super) fn notify_added(listing_id: &str, entry: FileEntry) {
     use crate::file_system::listing::diff_emitter::enqueue_diff;
     use crate::file_system::watcher::DiffChange;
 
+    if has_entry(listing_id, &entry.path) {
+        notify_modified(listing_id, entry);
+        return;
+    }
+
     let Some(index) = insert_entry_sorted(listing_id, entry.clone()) else {
-        return; // Already exists or listing gone
+        return; // Listing gone (or, harmless: lost a TOCTOU race against another add — Modified would no-op).
     };
 
     enqueue_diff(

apps/desktop/src-tauri/src/file_system/listing/caching_test.rs

@@ -4,7 +4,7 @@ use std::path::PathBuf;
 
 use super::caching::{
     CachedListing, LISTING_CACHE, ModifyResult, find_listings_for_path, find_listings_for_path_on_volume, has_entry,
-    insert_entry_sorted, remove_entry_by_path, update_entry_sorted,
+    insert_entry_sorted, notify_added, remove_entry_by_path, update_entry_sorted,
 };
 use super::metadata::FileEntry;
 use super::sorting::{DirectorySortMode, SortColumn, SortOrder};
@@ -228,6 +228,44 @@ fn test_insert_entry_sorted_returns_none_for_missing_listing() {
     assert_eq!(result, None);
 }
 
+#[test]
+fn notify_added_upserts_when_entry_already_present() {
+    // Race that motivated the upsert: SMB watcher fires an Added event mid-write
+    // (stat catches the file at partial size), then `write_from_stream`'s own
+    // post-close `notify_mutation` fires its Added with the final size. Without
+    // upsert the first-write wins (Samba's mid-write partial size sticks) and
+    // the FE shows the wrong size until the next manual refresh. With upsert
+    // the second observation updates the cached entry to the final size.
+    let id = insert_test_listing(
+        "notify_added_upsert",
+        "/test",
+        SortColumn::Name,
+        SortOrder::Ascending,
+        DirectorySortMode::LikeFiles,
+        vec![],
+    );
+
+    // First observation: partial size (what the watcher would see mid-write).
+    notify_added("notify_added_upsert", make_entry("photo.jpg", false, Some(2_359_284)));
+    // Second observation: final size (what the post-close stat sees).
+    notify_added("notify_added_upsert", make_entry("photo.jpg", false, Some(4_989_168)));
+
+    let cache = LISTING_CACHE.read().unwrap();
+    let listing = cache.get("notify_added_upsert").unwrap();
+    assert_eq!(
+        listing.entries.len(),
+        1,
+        "should still be exactly one entry, not duplicated"
+    );
+    assert_eq!(
+        listing.entries[0].size,
+        Some(4_989_168),
+        "second (final) size must overwrite the partial-size observation"
+    );
+    drop(cache);
+    cleanup_listing(&id);
+}
+
 // ============================================================================
 // remove_entry_by_path tests
 // ============================================================================