Bugfix: MTP delete emits write-cancelled on mid-iteration cancel

The volume-delete file loop's `?` propagation of `VolumeError::Cancelled` from `delete_with_cancel` mapped to `WriteOperationError::Cancelled` and exited the function without emitting `write-cancelled`. The top-of-loop check only catches cancels that land between iterations; a cancel that arrives during the in-flight per-file call dropped the terminal event, leaving the M4 settle contract incomplete (FE got `write-settled` but no `write-cancelled`, so the dialog waited 10 s for the fallback timer).

- Explicit `match` on `delete_with_cancel`'s result handles `VolumeError::Cancelled` by emitting `write-cancelled` before returning, and maps every other error as before.
- Adds an E2E throttle hook (`effective_copy_throttle_ms`) in the delete loop so cancel-during-delete tests on fast virtual MTP have a deterministic window. Zero-cost outside E2E mode.
- `mtp-cancel-volume-settled` spec sets a 200 ms throttle before F8 (clears in `finally`) so the cancel reliably lands while the BE is still in the delete loop, exercising the new mid-iteration emit path.

End-to-end verified: Linux Docker e2e 157/157 (was 153/4), macOS playwright e2e 145/145.

Author: vdavid

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

@@ -15,7 +15,7 @@ use super::types::{
 };
 use super::volume_copy::map_volume_error;
 use crate::file_system::listing::caching::try_get_watched_listing;
-use crate::file_system::volume::Volume;
+use crate::file_system::volume::{Volume, VolumeError};
 
 // ============================================================================
 // Delete implementation
@@ -714,10 +714,39 @@ pub(super) async fn delete_volume_files_with_progress_inner(
             });
         }
 
-        volume
+        // E2E throttle so cancel-during-delete tests on fast virtual MTP have a
+        // deterministic window in which to click Cancel before all files are
+        // gone. Reuses the copy throttle knob (`set_test_throttle` exposes a
+        // generic per-step throttle). Zero-cost outside E2E.
+        if let Some(ms) = crate::test_mode::effective_copy_throttle_ms()
+            && ms > 0
+        {
+            tokio::time::sleep(Duration::from_millis(ms)).await;
+        }
+
+        match volume
             .delete_with_cancel(&entry.path, Some(&state.backend_cancel))
             .await
-            .map_err(|e| map_volume_error(&entry.path.display().to_string(), e))?;
+        {
+            Ok(()) => {}
+            // Cancel landed mid-iteration (during the throttle sleep or inside
+            // delete_with_cancel itself). The top-of-loop cancel check only
+            // catches cancels that land between iterations; without this arm,
+            // the `?` propagation would surface as a Cancelled error with no
+            // `write-cancelled` event, breaking the M4 settle contract.
+            Err(VolumeError::Cancelled(_)) => {
+                events.emit_cancelled(WriteCancelledEvent {
+                    operation_id: operation_id.to_string(),
+                    operation_type: WriteOperationType::Delete,
+                    files_processed: files_done,
+                    rolled_back: false,
+                });
+                return Err(WriteOperationError::Cancelled {
+                    message: "Operation cancelled by user".to_string(),
+                });
+            }
+            Err(e) => return Err(map_volume_error(&entry.path.display().to_string(), e)),
+        }
 
         files_done += 1;
         bytes_done += entry.size;

apps/desktop/test/e2e-playwright/mtp-cancel-volume-settled.spec.ts

@@ -108,6 +108,17 @@ test.describe('MTP cancel: settle gate keeps "Cancelling…" until BE quiets dow
     await mcpNavToPath('left', `${mtpPath}/DCIM`)
     await mcpAwaitItem('left', 'cancel-00.jpg', 30)
 
+    // Slow each per-file delete so the Cancel click reliably lands BEFORE the
+    // op completes. Linux's virtual MTP can blow through the 12 tiny
+    // `cancel-*.jpg` files fast enough that without a throttle `write-complete`
+    // fires before our Cancel click is processed and no `write-cancelled` /
+    // `write-settled` events ever land — exactly what the test is verifying.
+    // 200 ms × 12 = 2.4 s worst case, plenty of room for the BE-side cancel
+    // round-trip.
+    await tauriPage.evaluate(
+      `window.__TAURI_INTERNALS__.invoke('set_test_throttle', { ms: 200 })`,
+    )
+
     // Subscribe to write-cancelled, write-settled, and write-complete so the
     // assertions can sequence events from the BE.
     await tauriPage.evaluate(`(async function() {
@@ -255,6 +266,10 @@ test.describe('MTP cancel: settle gate keeps "Cancelling…" until BE quiets dow
         )
       }
     } finally {
+      // Always clear the throttle so it doesn't slow down following tests.
+      await tauriPage.evaluate(
+        `window.__TAURI_INTERNALS__.invoke('set_test_throttle', { ms: null })`,
+      )
       await tauriPage.evaluate(`(async function() {
         const ids = ['__cancelledListenerId', '__settledListenerId', '__completeListenerId'];
         const events = ['write-cancelled', 'write-settled', 'write-complete'];