Conflict scan: dir flags on ScanConflict, optional source size

- `ScanConflict` gains `source_is_directory` + `dest_is_directory`; `SourceItemInfo` and the `SourceItemInput` IPC type gain `is_directory`. All four backends (`local_posix`, `smb`, `mtp`, `in_memory`) populate the flags from data already in hand — the dest listing entry and the caller-supplied source info. No new round-trips.
- `WriteConflictEvent.source_size` becomes `Option<u64>`. Both emit sites (`conflict.rs::build_conflict_event`, `transfer/volume_conflict.rs`'s Stop branch) carry the optional through; `size_difference` now collapses to `None` when either side is unknown, matching the existing `destination_size` treatment. The volume path surfaces the scan hint opportunistically (`None` = unknown) instead of forcing `Some(0)`.
- FE: regenerated typed bindings; `WriteConflictEvent.sourceSize` and `VolumeConflictInfo`'s new dir flags mirror the wire. `TransferProgressDialog` renders `(unknown)` for a null source size in the New slot, mirroring the destination side.
- Tests (TDD where it applied): backend dir-flag population + type-mismatch flags, `build_conflict_event` source-unknown None-collapse, serde round-trips for `ScanConflict` and `WriteConflictEvent`, and a FE component test for the `(unknown)` source-size render.
- No behavior change: dir-dir merge classification, dialogs, and the same-volume fast path are deferred to later milestones. `TransferDialog` sends `isDirectory: false` as a placeholder (the dialog has only paths, not per-item types) until the FE wiring lands later.

Author: vdavid

apps/desktop/src-tauri/src/commands/file_system/volume_copy.rs

@@ -146,6 +146,7 @@ pub async fn scan_volume_for_conflicts(
             name: item.name,
             size: item.size,
             modified: item.modified,
+            is_directory: item.is_directory,
         })
         .collect();
     let dest_path = PathBuf::from(dest_path);
@@ -170,4 +171,9 @@ pub struct SourceItemInput {
     pub size: u64,
     /// Modification time (Unix timestamp in seconds).
     pub modified: Option<i64>,
+    /// `true` when the source item is a directory. The FE has this from the
+    /// `FileEntry` it already holds; it lets `scan_for_conflicts` flag a
+    /// dir-vs-dir collision the FE can classify as a silent merge.
+    #[serde(default)]
+    pub is_directory: bool,
 }

apps/desktop/src-tauri/src/file_system/volume/backends/in_memory.rs

@@ -579,6 +579,8 @@ impl Volume for InMemoryVolume {
                         dest_size: existing.size.unwrap_or(0),
                         source_modified: item.modified,
                         dest_modified,
+                        source_is_directory: item.is_directory,
+                        dest_is_directory: existing.is_directory,
                     });
                 }
             }

apps/desktop/src-tauri/src/file_system/volume/backends/in_memory_test.rs

@@ -663,6 +663,7 @@ async fn test_scan_for_conflicts_no_conflicts() {
         name: "other.txt".to_string(),
         size: 100,
         modified: None,
+        is_directory: false,
     }];
 
     let conflicts = volume.scan_for_conflicts(&source_items, Path::new("/")).await.unwrap();
@@ -681,13 +682,78 @@ async fn test_scan_for_conflicts_detects_conflict() {
         name: "report.txt".to_string(),
         size: 200,
         modified: Some(1_700_000_000),
+        is_directory: false,
     }];
 
     let conflicts = volume.scan_for_conflicts(&source_items, Path::new("/")).await.unwrap();
     assert_eq!(conflicts.len(), 1);
     assert_eq!(conflicts[0].source_path, "report.txt");
     assert_eq!(conflicts[0].source_size, 200);
     assert_eq!(conflicts[0].dest_size, 11); // "old content"
+    // File vs file: both flags false.
+    assert!(!conflicts[0].source_is_directory);
+    assert!(!conflicts[0].dest_is_directory);
+}
+
+#[tokio::test]
+async fn test_scan_for_conflicts_populates_directory_flags() {
+    let volume = InMemoryVolume::new("Test");
+    // Dest holds a directory `photos` and a file `notes.txt`.
+    volume.create_directory(Path::new("/photos")).await.unwrap();
+    volume.create_file(Path::new("/notes.txt"), b"hello").await.unwrap();
+
+    // Source offers: a dir `photos` (→ dir-vs-dir merge), a file `notes.txt`
+    // (→ file-vs-file), and a file `photos.zip` that doesn't clash.
+    let source_items = vec![
+        SourceItemInfo {
+            name: "photos".to_string(),
+            size: 0,
+            modified: None,
+            is_directory: true,
+        },
+        SourceItemInfo {
+            name: "notes.txt".to_string(),
+            size: 99,
+            modified: None,
+            is_directory: false,
+        },
+        SourceItemInfo {
+            name: "photos.zip".to_string(),
+            size: 12,
+            modified: None,
+            is_directory: false,
+        },
+    ];
+
+    let conflicts = volume.scan_for_conflicts(&source_items, Path::new("/")).await.unwrap();
+    assert_eq!(conflicts.len(), 2);
+
+    let dir_conflict = conflicts.iter().find(|c| c.source_path == "photos").unwrap();
+    assert!(dir_conflict.source_is_directory, "source dir flag");
+    assert!(dir_conflict.dest_is_directory, "dest dir flag");
+
+    let file_conflict = conflicts.iter().find(|c| c.source_path == "notes.txt").unwrap();
+    assert!(!file_conflict.source_is_directory);
+    assert!(!file_conflict.dest_is_directory);
+}
+
+#[tokio::test]
+async fn test_scan_for_conflicts_type_mismatch_flags() {
+    let volume = InMemoryVolume::new("Test");
+    // Dest `data` is a file; source `data` is a directory.
+    volume.create_file(Path::new("/data"), b"x").await.unwrap();
+
+    let source_items = vec![SourceItemInfo {
+        name: "data".to_string(),
+        size: 0,
+        modified: None,
+        is_directory: true,
+    }];
+
+    let conflicts = volume.scan_for_conflicts(&source_items, Path::new("/")).await.unwrap();
+    assert_eq!(conflicts.len(), 1);
+    assert!(conflicts[0].source_is_directory, "source is a dir");
+    assert!(!conflicts[0].dest_is_directory, "dest is a file");
 }
 
 #[test]

apps/desktop/src-tauri/src/file_system/volume/backends/local_posix.rs

@@ -665,6 +665,8 @@ impl Volume for LocalPosixVolume {
                             dest_size: meta.len(),
                             source_modified: item.modified,
                             dest_modified,
+                            source_is_directory: item.is_directory,
+                            dest_is_directory: meta.is_dir(),
                         });
                     }
                 }

apps/desktop/src-tauri/src/file_system/volume/backends/local_posix_test.rs

@@ -551,11 +551,13 @@ async fn test_scan_for_conflicts_no_conflicts() {
             name: "newfile.txt".to_string(),
             size: 100,
             modified: None,
+            is_directory: false,
         },
         SourceItemInfo {
             name: "another.txt".to_string(),
             size: 200,
             modified: None,
+            is_directory: false,
         },
     ];
 
@@ -584,16 +586,19 @@ async fn test_scan_for_conflicts_with_conflicts() {
             name: "existing.txt".to_string(),
             size: 100,
             modified: Some(1_700_000_000),
+            is_directory: false,
         },
         SourceItemInfo {
             name: "newfile.txt".to_string(),
             size: 200,
             modified: None,
+            is_directory: false,
         },
         SourceItemInfo {
             name: "another.txt".to_string(),
             size: 300,
             modified: Some(1_700_000_000),
+            is_directory: false,
         },
     ];
 

apps/desktop/src-tauri/src/file_system/volume/backends/mtp.rs

@@ -731,6 +731,8 @@ impl Volume for MtpVolume {
                         dest_size: existing.size.unwrap_or(0),
                         source_modified: item.modified,
                         dest_modified,
+                        source_is_directory: item.is_directory,
+                        dest_is_directory: existing.is_directory,
                     });
                 }
             }

apps/desktop/src-tauri/src/file_system/volume/backends/smb.rs

@@ -1830,6 +1830,8 @@ impl Volume for SmbVolume {
                         dest_size: existing.size.unwrap_or(0),
                         source_modified: item.modified,
                         dest_modified,
+                        source_is_directory: item.is_directory,
+                        dest_is_directory: existing.is_directory,
                     });
                 }
             }

apps/desktop/src-tauri/src/file_system/volume/backends/smb_integration_test.rs

@@ -542,11 +542,13 @@ async fn smb_integration_scan_for_conflicts() {
             name: "exists.txt".to_string(),
             size: 100,
             modified: Some(0),
+            is_directory: false,
         },
         SourceItemInfo {
             name: "missing.txt".to_string(),
             size: 200,
             modified: Some(0),
+            is_directory: false,
         },
     ];
 

apps/desktop/src-tauri/src/file_system/volume/mod.rs

@@ -198,6 +198,13 @@ pub struct ScanConflict {
     pub source_modified: Option<i64>,
     /// Unix timestamp in seconds.
     pub dest_modified: Option<i64>,
+    /// `true` when the source item is a directory (from the caller-supplied
+    /// `SourceItemInfo`). Lets the FE classify a dir-vs-dir collision as a
+    /// silent merge ("will merge") instead of a conflict.
+    pub source_is_directory: bool,
+    /// `true` when the destination item is a directory (from the dest listing
+    /// entry). See `source_is_directory`.
+    pub dest_is_directory: bool,
 }
 
 /// Space information for a volume.
@@ -220,6 +227,10 @@ pub struct SourceItemInfo {
     pub size: u64,
     /// Unix timestamp in seconds.
     pub modified: Option<i64>,
+    /// `true` when the source item is a directory. The caller knows this from
+    /// the `FileEntry` it already has in hand; backends copy it straight onto
+    /// the resulting `ScanConflict::source_is_directory`.
+    pub is_directory: bool,
 }
 
 /// Error type for volume operations.
@@ -1027,3 +1038,49 @@ mod id_tests {
         assert_eq!(path_to_id("/Volumes/External"), "volumesexternal");
     }
 }
+
+#[cfg(test)]
+mod scan_conflict_serde_tests {
+    use super::*;
+
+    #[test]
+    fn scan_conflict_round_trips_directory_flags() {
+        let conflict = ScanConflict {
+            source_path: "photos".to_string(),
+            dest_path: "/dst/photos".to_string(),
+            source_size: 0,
+            dest_size: 4_096,
+            source_modified: Some(1_700_000_000),
+            dest_modified: Some(1_700_000_001),
+            source_is_directory: true,
+            dest_is_directory: true,
+        };
+
+        let json = serde_json::to_string(&conflict).unwrap();
+        // camelCase on the wire (matches the FE binding).
+        assert!(json.contains("\"sourceIsDirectory\":true"), "json was: {json}");
+        assert!(json.contains("\"destIsDirectory\":true"), "json was: {json}");
+
+        let back: ScanConflict = serde_json::from_str(&json).unwrap();
+        assert!(back.source_is_directory);
+        assert!(back.dest_is_directory);
+    }
+
+    #[test]
+    fn scan_conflict_round_trips_type_mismatch_flags() {
+        let conflict = ScanConflict {
+            source_path: "data".to_string(),
+            dest_path: "/dst/data".to_string(),
+            source_size: 10,
+            dest_size: 20,
+            source_modified: None,
+            dest_modified: None,
+            source_is_directory: true,
+            dest_is_directory: false,
+        };
+
+        let back: ScanConflict = serde_json::from_str(&serde_json::to_string(&conflict).unwrap()).unwrap();
+        assert!(back.source_is_directory);
+        assert!(!back.dest_is_directory);
+    }
+}

apps/desktop/src-tauri/src/file_system/write_operations/conflict.rs

@@ -397,18 +397,26 @@ fn build_conflict_event(
     let destination_is_directory = dest_meta.map(|m| m.is_dir()).unwrap_or(false);
 
     // Files: use `metadata.len()` directly. Directories: use the caller-
-    // supplied recursive total (the BE never walks a destination tree).
-    let source_size = if source_is_directory {
-        source_size_for_dir.unwrap_or(0)
+    // supplied recursive total (the BE never walks a destination tree). On the
+    // local-FS path the source is always stat-able, so a file source is always
+    // `Some`; a folder source is `Some` post-preflight and `None` only on the
+    // rare skip-preflight path.
+    let source_size: Option<u64> = if source_is_directory {
+        source_size_for_dir
     } else {
-        source_meta.map(|m| m.len()).unwrap_or(0)
+        source_meta.map(|m| m.len())
     };
     let destination_size = if destination_is_directory {
         destination_size_for_dir
     } else {
         dest_meta.map(|m| m.len())
     };
-    let size_difference = destination_size.map(|d| d as i64 - source_size as i64);
+    // Collapse to `None` when either side is unknown — the FE can't render a
+    // meaningful "(larger)" annotation without both numbers.
+    let size_difference = match (destination_size, source_size) {
+        (Some(d), Some(s)) => Some(d as i64 - s as i64),
+        _ => None,
+    };
 
     let unix_secs = |m: Option<&fs::Metadata>| -> Option<i64> {
         m?.modified()
@@ -968,7 +976,7 @@ mod build_conflict_event_tests {
             Some(99999),
         );
 
-        assert_eq!(event.source_size, 5);
+        assert_eq!(event.source_size, Some(5));
         assert_eq!(event.destination_size, Some(6));
         assert_eq!(event.size_difference, Some(1));
     }
@@ -997,7 +1005,7 @@ mod build_conflict_event_tests {
             Some(4_096_000),
         );
 
-        assert_eq!(event.source_size, 1);
+        assert_eq!(event.source_size, Some(1));
         assert_eq!(event.destination_size, Some(4_096_000));
         assert_eq!(event.size_difference, Some(4_095_999));
     }
@@ -1018,7 +1026,7 @@ mod build_conflict_event_tests {
 
         let event = build_conflict_event("op", &source, &dest, Some(&source_meta), Some(&dest_meta), None, None);
 
-        assert_eq!(event.source_size, 1);
+        assert_eq!(event.source_size, Some(1));
         assert_eq!(event.destination_size, None);
         assert_eq!(event.size_difference, None);
     }
@@ -1046,10 +1054,31 @@ mod build_conflict_event_tests {
             None,
         );
 
-        assert_eq!(event.source_size, 123_456);
+        assert_eq!(event.source_size, Some(123_456));
         assert_eq!(event.destination_size, Some(2));
         assert_eq!(event.size_difference, Some(2 - 123_456));
     }
+
+    #[test]
+    fn folder_source_with_unknown_size_surfaces_none() {
+        // A folder source with no pre-flight scan total (the skip-preflight /
+        // fast-path case) surfaces `source_size: None`, and `size_difference`
+        // collapses to `None` just as it does when the destination is unknown.
+        let temp = TempDir::new().unwrap();
+        let source = temp.path().join("payload");
+        let dest = temp.path().join("notes.txt");
+        fs::create_dir(&source).unwrap();
+        fs::write(&dest, b"hi").unwrap();
+
+        let source_meta = fs::metadata(&source).unwrap();
+        let dest_meta = fs::metadata(&dest).unwrap();
+
+        let event = build_conflict_event("op", &source, &dest, Some(&source_meta), Some(&dest_meta), None, None);
+
+        assert_eq!(event.source_size, None);
+        assert_eq!(event.destination_size, Some(2));
+        assert_eq!(event.size_difference, None);
+    }
 }
 
 #[cfg(test)]