Drag&drop: Match Finder for the drop operation

- Default operation is now volume-aware, matching Finder: same volume → Move, cross-volume → Copy. Previously it was always Copy, which felt inconsistent with the outgoing-to-Desktop drag (where macOS picks Move).
- Modifier overrides: Alt forces Copy (beats Cmd/Shift); Cmd forces Move (Finder); Shift also forces Move (Windows convention, kept as a friendly accelerator).
- Same `pickDropOperation` feeds both the live overlay label and the actual drop, so they can no longer disagree.
- Native side now reads Alt + Cmd + Shift bits from `[NSEvent modifierFlags]` and emits all three on the `drag-modifiers` event.
- Decision and rationale recorded in `drag/CLAUDE.md`.

Author: vdavid

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

@@ -7,15 +7,16 @@
 //!
 //! Events emitted:
 //! - `drag-image-size` `{ width, height }` — on drag enter
-//! - `drag-modifiers` `{ altHeld }` — on drag enter and every drag update (only when changed)
+//! - `drag-modifiers` `{ altHeld, cmdHeld, shiftHeld }` — on drag enter and every drag update (only when changed)
 //!
 //! ## Resilience
 //!
 //! All native API calls are guarded against method removal. The webview class is discovered
 //! from the actual webview instance (not a hardcoded name), so wry version changes are safe.
 //! If macOS deprecates APIs we rely on, the swizzle degrades gracefully:
 //! - Drag image detection disabled → the DOM overlay is always shown (redundant but functional)
-//! - Modifier key detection disabled → falls back to JS keydown/keyup (works when webview has focus)
+//! - Modifier key detection disabled → falls back to JS keydown/keyup (works when webview has focus,
+//!   but not during OS-level drags initiated outside the window)
 //! - Image swapping disabled → self-drags show the OS drag image over the window (functional)
 //!
 //! Rust panics inside swizzled functions are caught via `catch_unwind` to prevent crashes
@@ -35,28 +36,38 @@ use tauri::{AppHandle, Emitter, Manager};
 
 use crate::drag_image_swap;
 
+/// NSEventModifierFlagShift = 1 << 17
+const NS_EVENT_MODIFIER_FLAG_SHIFT: usize = 1 << 17;
 /// NSEventModifierFlagOption = 1 << 19 (Option/Alt key)
 const NS_EVENT_MODIFIER_FLAG_OPTION: usize = 1 << 19;
+/// NSEventModifierFlagCommand = 1 << 20
+const NS_EVENT_MODIFIER_FLAG_COMMAND: usize = 1 << 20;
 
 #[derive(Clone, Serialize)]
 struct DragImageSize {
     width: f64,
     height: f64,
 }
 
-#[derive(Clone, Serialize)]
+#[derive(Clone, Copy, PartialEq, Eq, Serialize)]
 struct DragModifiers {
     #[serde(rename = "altHeld")]
     alt_held: bool,
+    #[serde(rename = "cmdHeld")]
+    cmd_held: bool,
+    #[serde(rename = "shiftHeld")]
+    shift_held: bool,
 }
 
 static ORIGINAL_ENTERED_IMP: OnceLock<Imp> = OnceLock::new();
 static ORIGINAL_UPDATED_IMP: OnceLock<Imp> = OnceLock::new();
 static ORIGINAL_EXITED_IMP: OnceLock<Imp> = OnceLock::new();
 static APP_HANDLE: OnceLock<AppHandle> = OnceLock::new();
 
-/// Tracks previous alt state so we only emit `drag-modifiers` when it changes.
+/// Tracks previous modifier state so we only emit `drag-modifiers` when something changes.
 static LAST_ALT_HELD: AtomicBool = AtomicBool::new(false);
+static LAST_CMD_HELD: AtomicBool = AtomicBool::new(false);
+static LAST_SHIFT_HELD: AtomicBool = AtomicBool::new(false);
 
 // Warn-once flags to prevent log spam for issues that recur on every drag event.
 static WARNED_NSEVENT_MISSING: AtomicBool = AtomicBool::new(false);
@@ -178,41 +189,53 @@ unsafe fn install_swizzles(webview_ptr: *mut std::ffi::c_void) {
 
 // --- Modifier key detection ---
 
-/// Reads the current Option/Alt key state from `[NSEvent modifierFlags]`.
+/// Reads the current Alt/Cmd/Shift modifier state from `[NSEvent modifierFlags]`.
 /// This is a class method that reads hardware state — works even when the webview isn't focused.
-/// Returns `false` if NSEvent can't be found (graceful degradation).
-fn is_option_held() -> bool {
+/// Returns all flags as `false` if NSEvent can't be found (graceful degradation).
+fn read_modifiers() -> DragModifiers {
     let Some(cls) = AnyClass::get(c"NSEvent") else {
         warn_once(
             &WARNED_NSEVENT_MISSING,
-            "drag_image_detection: NSEvent class not found — Alt/Option detection during drags \
+            "drag_image_detection: NSEvent class not found — modifier key detection during drags \
              is disabled. This is a core AppKit class and shouldn't disappear; if it did, check \
              whether macOS moved it to a different framework or renamed it. Modifier detection \
              falls back to JS keydown/keyup, which doesn't work during OS-level drags.",
         );
-        return false;
+        return DragModifiers {
+            alt_held: false,
+            cmd_held: false,
+            shift_held: false,
+        };
     };
     let flags: usize = unsafe { msg_send![cls, modifierFlags] };
-    flags & NS_EVENT_MODIFIER_FLAG_OPTION != 0
+    DragModifiers {
+        alt_held: flags & NS_EVENT_MODIFIER_FLAG_OPTION != 0,
+        cmd_held: flags & NS_EVENT_MODIFIER_FLAG_COMMAND != 0,
+        shift_held: flags & NS_EVENT_MODIFIER_FLAG_SHIFT != 0,
+    }
 }
 
-/// Emits `drag-modifiers` if the alt state changed since last emission.
+/// Emits `drag-modifiers` if any tracked modifier changed since last emission.
 fn emit_modifiers_if_changed() {
-    let alt_held = is_option_held();
-    let prev = LAST_ALT_HELD.swap(alt_held, Ordering::Relaxed);
-    if alt_held != prev
+    let mods = read_modifiers();
+    let prev_alt = LAST_ALT_HELD.swap(mods.alt_held, Ordering::Relaxed);
+    let prev_cmd = LAST_CMD_HELD.swap(mods.cmd_held, Ordering::Relaxed);
+    let prev_shift = LAST_SHIFT_HELD.swap(mods.shift_held, Ordering::Relaxed);
+    if (mods.alt_held != prev_alt || mods.cmd_held != prev_cmd || mods.shift_held != prev_shift)
         && let Some(app_handle) = APP_HANDLE.get()
     {
-        let _ = app_handle.emit("drag-modifiers", DragModifiers { alt_held });
+        let _ = app_handle.emit("drag-modifiers", mods);
     }
 }
 
 /// Emits `drag-modifiers` unconditionally (used on drag enter to set initial state).
 fn emit_modifiers_forced() {
-    let alt_held = is_option_held();
-    LAST_ALT_HELD.store(alt_held, Ordering::Relaxed);
+    let mods = read_modifiers();
+    LAST_ALT_HELD.store(mods.alt_held, Ordering::Relaxed);
+    LAST_CMD_HELD.store(mods.cmd_held, Ordering::Relaxed);
+    LAST_SHIFT_HELD.store(mods.shift_held, Ordering::Relaxed);
     if let Some(app_handle) = APP_HANDLE.get() {
-        let _ = app_handle.emit("drag-modifiers", DragModifiers { alt_held });
+        let _ = app_handle.emit("drag-modifiers", mods);
     }
 }
 

apps/desktop/src/lib/file-explorer/drag/CLAUDE.md

@@ -46,8 +46,11 @@ Key files:
 - `drop-target-hit-testing.ts` — Pure logic: `document.elementFromPoint()` + `data-drop-target-path` walk
 - `drop-target-validation.ts` — Pure logic: blocks drops onto the source itself or into a descendant
 - `DragOverlay.svelte` + `drag-overlay.svelte.ts` — Floating label near cursor
-- `../modifier-key-tracker.svelte.ts` — Alt/Option state (DragDropEvent doesn't include modifiers; lives in parent
+- `../modifier-key-tracker.svelte.ts` — Alt/Cmd/Shift state (DragDropEvent doesn't include modifiers; lives in parent
   `file-explorer/` directory)
+- `drop-operation.ts` — Pure logic: resolves the `'move' | 'copy'` operation from source/target paths, the volumes list,
+  and the current modifier state. Same function feeds the overlay label and the actual drop, so the displayed and
+  executed operation can never disagree.
 - `drag-position.ts` — Corrects Tauri coords for docked DevTools (dev-only, zero overhead in prod)
 - Integration in `DualPaneExplorer.svelte`
 
@@ -68,7 +71,7 @@ Key files:
 ## Key decisions
 
 - **Decision**: Always show confirmation dialog on drop
-  - **Why**: Drag-and-drop is imprecise. Default operation is copy (safer than move).
+  - **Why**: Drag-and-drop is imprecise. The dialog is the safety net regardless of which operation is preselected.
 - **Decision**: Same-pane pane-level drops are no-ops
   - **Why**: Dropping onto a subfolder within the same pane is valid.
 - **Decision**: Block drops onto the source itself or into a descendant
@@ -92,6 +95,21 @@ Key files:
     arbitrate the operation natively.
 - **Decision**: Modifier keys tracked via NSEvent.modifierFlags
   - **Why**: Tauri doesn't expose modifier state in DragDropEvent. Emits `drag-modifiers` event only when state changes.
+- **Decision**: Drop operation follows Finder's volume-aware default plus Alt/Cmd/Shift modifiers
+  - **Default**: same volume → Move, cross-volume → Copy (matches Finder's behavior on a stock macOS install).
+  - **Alt (Option)** held → force Copy. Beats Cmd/Shift if both are held — the user is asking for Copy.
+  - **Cmd** held → force Move. Matches Finder's force-move modifier.
+  - **Shift** held → force Move. Windows convention; included as a friendly accelerator for cross-platform users.
+  - **Why**: Earlier we kept Copy-as-default for safety, but it created a confusing inconsistency: dragging out of Cmdr
+    to the Desktop becomes Move (macOS arbitrates the outgoing operation from the source mask + modifiers), so the same
+    gesture meant different things inside vs. outside the app. Matching Finder removes that surprise. The confirmation
+    dialog still catches mistakes, so we don't lose the safety net.
+  - The same `pickDropOperation` runs for both the live overlay (`handleDragOver`) and the actual drop (`handleDrop`),
+    so the two can't diverge.
+- **Decision**: Internal-drop modifier semantics align with the outgoing arbitration macOS does for us
+  - **Why**: For drags out to other apps, AppKit arbitrates the operation from the source mask plus modifiers (Alt →
+    Copy, Cmd → Move, Ctrl-Alt → Link). We own the choice for internal drops, so we replicate the same Alt/Cmd
+    convention. Shift is an extra Move accelerator for Windows-trained users; Link isn't supported.
 - **Decision**: Viewport position correction only in dev mode
   - **Why**: DevTools docked mode shrinks viewport but Tauri reports window-relative positions. Offset computed via
     `outerSize()` vs `innerHeight`. Zero overhead in prod.

apps/desktop/src/lib/file-explorer/drag/drop-operation.test.ts

@@ -0,0 +1,141 @@
+import { describe, expect, it } from 'vitest'
+import type { VolumeInfo } from '$lib/file-explorer/types'
+import { findVolumeIdForPath, isSameVolume, pickDropOperation } from './drop-operation'
+
+const root: VolumeInfo = { id: 'boot', name: 'Macintosh HD', path: '/', category: 'main_volume', isEjectable: false }
+const usb: VolumeInfo = {
+  id: 'usb',
+  name: 'MyDrive',
+  path: '/Volumes/MyDrive',
+  category: 'attached_volume',
+  isEjectable: true,
+}
+const usbPrefix: VolumeInfo = {
+  id: 'usbprefix',
+  name: 'MyDrive2',
+  path: '/Volumes/MyDrive2',
+  category: 'attached_volume',
+  isEjectable: true,
+}
+const volumes: VolumeInfo[] = [root, usb, usbPrefix]
+
+const noMods = { altHeld: false, cmdHeld: false, shiftHeld: false }
+
+describe('findVolumeIdForPath', () => {
+  it('matches the longest-prefix volume', () => {
+    expect(findVolumeIdForPath('/Volumes/MyDrive/foo.txt', volumes)).toBe('usb')
+  })
+
+  it('falls back to root for paths not under any mount', () => {
+    expect(findVolumeIdForPath('/Users/dave/notes.md', volumes)).toBe('boot')
+  })
+
+  it('does not match a sibling whose name is a prefix', () => {
+    // /Volumes/MyDrive2/foo must not match the /Volumes/MyDrive volume
+    expect(findVolumeIdForPath('/Volumes/MyDrive2/foo', volumes)).toBe('usbprefix')
+  })
+
+  it('returns null when no volume matches', () => {
+    expect(findVolumeIdForPath('/Users/dave', [usb])).toBeNull()
+  })
+
+  it('matches a path equal to the volume path itself', () => {
+    expect(findVolumeIdForPath('/Volumes/MyDrive', volumes)).toBe('usb')
+  })
+})
+
+describe('isSameVolume', () => {
+  it('returns true for two paths on the boot volume', () => {
+    expect(isSameVolume('/Users/a', '/Users/b/c', volumes)).toBe(true)
+  })
+
+  it('returns false for cross-volume paths', () => {
+    expect(isSameVolume('/Users/a', '/Volumes/MyDrive/x', volumes)).toBe(false)
+  })
+
+  it('returns false when the source resolves to no volume', () => {
+    expect(isSameVolume('/orphan', '/Users/a', [usb])).toBe(false)
+  })
+})
+
+describe('pickDropOperation', () => {
+  const baseOpts = {
+    sourcePath: '/Users/a/file.txt',
+    targetPath: '/Users/b',
+    volumes,
+  }
+
+  it('defaults to Move when source and target share a volume', () => {
+    expect(pickDropOperation({ ...baseOpts, modifiers: noMods })).toBe('move')
+  })
+
+  it('defaults to Copy when source and target are on different volumes', () => {
+    expect(
+      pickDropOperation({
+        ...baseOpts,
+        targetPath: '/Volumes/MyDrive/dst',
+        modifiers: noMods,
+      }),
+    ).toBe('copy')
+  })
+
+  it('Alt forces Copy even on same-volume drops', () => {
+    expect(
+      pickDropOperation({
+        ...baseOpts,
+        modifiers: { altHeld: true, cmdHeld: false, shiftHeld: false },
+      }),
+    ).toBe('copy')
+  })
+
+  it('Cmd forces Move even on cross-volume drops', () => {
+    expect(
+      pickDropOperation({
+        ...baseOpts,
+        targetPath: '/Volumes/MyDrive/dst',
+        modifiers: { altHeld: false, cmdHeld: true, shiftHeld: false },
+      }),
+    ).toBe('move')
+  })
+
+  it('Shift forces Move even on cross-volume drops', () => {
+    expect(
+      pickDropOperation({
+        ...baseOpts,
+        targetPath: '/Volumes/MyDrive/dst',
+        modifiers: { altHeld: false, cmdHeld: false, shiftHeld: true },
+      }),
+    ).toBe('move')
+  })
+
+  it('Alt beats Cmd when both are held (force-Copy wins)', () => {
+    expect(
+      pickDropOperation({
+        ...baseOpts,
+        modifiers: { altHeld: true, cmdHeld: true, shiftHeld: false },
+      }),
+    ).toBe('copy')
+  })
+
+  it('falls back to Copy when source path is missing', () => {
+    expect(
+      pickDropOperation({
+        sourcePath: null,
+        targetPath: '/Users/b',
+        volumes,
+        modifiers: noMods,
+      }),
+    ).toBe('copy')
+  })
+
+  it('falls back to Copy when target path is missing', () => {
+    expect(
+      pickDropOperation({
+        sourcePath: '/Users/a',
+        targetPath: null,
+        volumes,
+        modifiers: noMods,
+      }),
+    ).toBe('copy')
+  })
+})

apps/desktop/src/lib/file-explorer/drag/drop-operation.ts

@@ -0,0 +1,56 @@
+// Picks the operation (move or copy) for a drag-and-drop drop, following Finder conventions:
+//   - Option (Alt) held       → Copy (force, beats other modifiers)
+//   - Cmd or Shift held       → Move (force; Cmd is Finder, Shift is the Windows accelerator)
+//   - Otherwise, same volume  → Move
+//   - Otherwise               → Copy
+
+import type { VolumeInfo } from '$lib/file-explorer/types'
+
+export interface ModifierState {
+  altHeld: boolean
+  cmdHeld: boolean
+  shiftHeld: boolean
+}
+
+/**
+ * Returns the volume ID whose `path` is the longest prefix of `path`, or `null` if none matches.
+ * Treats `/` specially so it matches everything but loses to longer mounts (`/Volumes/Foo`).
+ */
+export function findVolumeIdForPath(path: string, volumes: readonly VolumeInfo[]): string | null {
+  let best: VolumeInfo | null = null
+  for (const v of volumes) {
+    if (!v.path) continue
+    const matches = v.path === '/' ? path.startsWith('/') : path === v.path || path.startsWith(`${v.path}/`)
+    if (matches && (!best || v.path.length > best.path.length)) {
+      best = v
+    }
+  }
+  return best?.id ?? null
+}
+
+/** True when source and target paths resolve to the same volume. False if either can't be resolved. */
+export function isSameVolume(sourcePath: string, targetPath: string, volumes: readonly VolumeInfo[]): boolean {
+  const a = findVolumeIdForPath(sourcePath, volumes)
+  if (a === null) return false
+  return a === findVolumeIdForPath(targetPath, volumes)
+}
+
+/**
+ * Picks the drop operation. The `sourcePath` should be the first path in the drag (volume affinity is
+ * deterministic and matches the common case of single-volume selections). When the source can't be
+ * resolved to a volume, falls back to Copy (the safer default).
+ */
+export function pickDropOperation(opts: {
+  sourcePath: string | null
+  targetPath: string | null
+  volumes: readonly VolumeInfo[]
+  modifiers: ModifierState
+}): 'move' | 'copy' {
+  const { altHeld, cmdHeld, shiftHeld } = opts.modifiers
+  if (altHeld) return 'copy'
+  if (cmdHeld || shiftHeld) return 'move'
+  if (opts.sourcePath && opts.targetPath && isSameVolume(opts.sourcePath, opts.targetPath, opts.volumes)) {
+    return 'move'
+  }
+  return 'copy'
+}