@@ -0,0 +1,118 @@
+/**
+ * @vitest-environment jsdom
+ */
+import { act } from 'react'
+import { createRoot, type Root } from 'react-dom/client'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import { useDragTeardown } from '@/app/workspace/[workspaceId]/components/folders/use-drag-teardown'
+
+const mountedRoots: Root[] = []
+
+function renderDragTeardown(teardown: () => void) {
+  ;(globalThis as { IS_REACT_ACT_ENVIRONMENT?: boolean }).IS_REACT_ACT_ENVIRONMENT = true
+  const root = createRoot(document.createElement('div'))
+  mountedRoots.push(root)
+
+  function Probe() {
+    useDragTeardown(teardown)
+    return null
+  }
+
+  act(() => {
+    root.render(<Probe />)
+  })
+}
+
+function fire(type: string) {
+  act(() => {
+    window.dispatchEvent(new Event(type, { bubbles: true }))
+  })
+}
+
+beforeEach(() => {
+  vi.useFakeTimers()
+})
+
+afterEach(() => {
+  act(() => {
+    for (const root of mountedRoots.splice(0)) root.unmount()
+  })
+  vi.useRealTimers()
+})
+
+describe('useDragTeardown', () => {
+  it('tears down on dragend', () => {
+    const teardown = vi.fn()
+    renderDragTeardown(teardown)
+
+    fire('dragover')
+    fire('dragend')
+
+    expect(teardown).toHaveBeenCalledTimes(1)
+  })
+
+  it('tears down on drop', () => {
+    const teardown = vi.fn()
+    renderDragTeardown(teardown)
+
+    fire('dragover')
+    fire('drop')
+
+    expect(teardown).toHaveBeenCalledTimes(1)
+  })
+
+  it('tears down on the first pointermove after a drag, which dragend can miss', () => {
+    // Spring-loading unmounts the source row, so `dragend` — dispatched at that node — never
+    // reaches window. Browsers suppress pointer events during a drag, so the first one after
+    // is an exact signal that the drag ended.
+    const teardown = vi.fn()
+    renderDragTeardown(teardown)
+
+    fire('dragover')
+    fire('pointermove')
+
+    expect(teardown).toHaveBeenCalledTimes(1)
+  })
+
+  it('never tears down from the passage of time alone', () => {
+    // Regression: an idle-timeout version of this tore the drag down whenever the user rested
+    // on a folder waiting for it to spring open — the drag model reports only about every
+    // 350ms while the pointer is still, so any timeout in that range trips on a held drag.
+    // Nothing here may depend on a timer, so advancing the clock must change nothing.
+    const teardown = vi.fn()
+    renderDragTeardown(teardown)
+
+    fire('dragover')
+    act(() => {
+      vi.advanceTimersByTime(30_000)
+    })
+
+    expect(teardown).not.toHaveBeenCalled()
+
+    // And the drag is still live, so a real end signal still lands.
+    fire('dragend')
+    expect(teardown).toHaveBeenCalledTimes(1)
+  })
+
+  it('ignores pointer movement when no drag is in flight', () => {
+    const teardown = vi.fn()
+    renderDragTeardown(teardown)
+
+    fire('pointermove')
+    fire('pointermove')
+
+    expect(teardown).not.toHaveBeenCalled()
+  })
+
+  it('tears down once per drag, not on every event after it ends', () => {
+    const teardown = vi.fn()
+    renderDragTeardown(teardown)
+
+    fire('dragover')
+    fire('dragend')
+    fire('pointermove')
+    fire('pointermove')
+
+    expect(teardown).toHaveBeenCalledTimes(1)
+  })
+})
@@ -2,32 +2,24 @@
 
 import { useEffect, useRef } from 'react'
 
-/**
- * How long `dragover` must go silent before the drag is presumed over.
- *
- * `dragover` fires continuously (roughly per animation frame) for as long as a drag is live and
- * inside the window, so a gap this long means the drag ended somewhere no event of ours can
- * observe. Generous on purpose: the cost of firing late is a few frames of stale drag styling,
- * while firing early would tear down a drag the user is still holding.
- */
-const DRAG_IDLE_TEARDOWN_MS = 400
-
 /**
  * Runs a drag's teardown wherever the drag actually ends.
  *
  * Three signals, because no single one is reliable here:
  *
  * 1. `drop` on `window` — a release over any valid target, wherever it bubbles from.
  * 2. `dragend` on `window` — the normal end of a drag whose source row still exists.
- * 3. A `dragover` idle watchdog — the case the first two miss. `dragend` is dispatched *at the
+ * 3. `pointermove` on `window` — the case the first two miss. `dragend` is dispatched *at the
  *    source node*, so once spring-loading navigates the list and unmounts that row, the event
  *    has no path to `window` and neither listener above ever runs. Cancelling with Escape or
  *    releasing over nothing then leaves the ghost on the page, every row frozen at drag
  *    opacity, and the spring-open set uncleared so those folders refuse to open again.
  *
- * The watchdog also covers a drag that leaves the window entirely. If it re-enters, the visual
- * state has been reset but the drop still resolves — the row ids live in `dataTransfer`, not in
- * the state this tears down.
+ * The third signal works because browsers suppress mouse and pointer events for the duration of
+ * a native drag: the first `pointermove` after one starts can only mean it is over. That makes
+ * it exact, where a timer is not — the drag model fires `dragover` on roughly a 350ms cadence
+ * while the pointer is stationary, so an idle-timeout version of this tore down mid-drag
+ * whenever the user rested on a folder waiting for it to spring open.
  *
  * `teardown` is read through a ref and the listeners bind once, deliberately. Depending on the
  * callback would re-run this effect on every render, and the teardown wired into it would then
@@ -38,32 +30,32 @@ export function useDragTeardown(teardown: () => void): void {
   teardownRef.current = teardown
 
   useEffect(() => {
-    let idleTimer: ReturnType<typeof setTimeout> | null = null
-
-    const clearIdleTimer = () => {
-      if (idleTimer !== null) clearTimeout(idleTimer)
-      idleTimer = null
+    /**
+     * Set from `dragover` rather than `dragstart` so the flag only turns on once a drag is
+     * genuinely under way, and so a stray `pointermove` before the drag engages cannot tear
+     * down a drag that never started.
+     */
+    let isDragging = false
+
+    const markDragging = () => {
+      isDragging = true
     }
 
-    const runTeardown = () => {
-      clearIdleTimer()
+    const endDrag = () => {
+      if (!isDragging) return
+      isDragging = false
       teardownRef.current()
     }
 
-    /** Restarted on every `dragover`; only elapses once the drag stops reporting. */
-    const handleDragOver = () => {
-      clearIdleTimer()
-      idleTimer = setTimeout(runTeardown, DRAG_IDLE_TEARDOWN_MS)
-    }
-
-    window.addEventListener('dragend', runTeardown)
-    window.addEventListener('drop', runTeardown)
-    window.addEventListener('dragover', handleDragOver)
+    window.addEventListener('dragover', markDragging)
+    window.addEventListener('dragend', endDrag)
+    window.addEventListener('drop', endDrag)
+    window.addEventListener('pointermove', endDrag)
     return () => {
-      clearIdleTimer()
-      window.removeEventListener('dragend', runTeardown)
-      window.removeEventListener('drop', runTeardown)
-      window.removeEventListener('dragover', handleDragOver)
+      window.removeEventListener('dragover', markDragging)
+      window.removeEventListener('dragend', endDrag)
+      window.removeEventListener('drop', endDrag)
+      window.removeEventListener('pointermove', endDrag)
     }
   }, [])
 }
@@ -283,6 +283,12 @@ export function useFolderRowDragDrop({
          */
         if (sourceRowIds.length > 0) {
           setActiveDropTargetId(rowId)
+          /**
+           * The row is inside the scroll container, so moving onto it fires `dragleave` there
+           * with a contained `relatedTarget` — which that handler deliberately ignores. Without
+           * clearing here the row and the body would both render as the target at once.
+           */
+          setIsBodyDropActive(false)
           /**
            * Armed on the same condition as the highlight, so a folder only springs open where a
            * drop was already possible. A folder the drag cannot legally enter never opens.
@@ -323,19 +329,20 @@ export function useFolderRowDragDrop({
       onDragEnd: endDrag,
       body: {
         isActive: isBodyDropActive,
-        canDrop: canEdit && draggedRowIds.size > 0,
         onDragOver: (e: DragEvent<HTMLDivElement>) => {
           const sourceRowIds = draggedRowIdsRef.current
-          if (sourceRowIds.length === 0) return
           /**
-           * Only light up when the drop would actually move something. A drag whose rows all
-           * already live here is a no-op, and showing a target for it would promise a change
-           * that never happens.
+           * Recomputed on every event rather than latched, because a spring-open changes the
+           * destination mid-drag: the folder just entered may not accept this drag, and an
+           * early return would leave the outline showing from the previous folder. Setting the
+           * same value repeatedly is free — React bails on an unchanged state write.
            */
-          if (!resolveMoveToFolder(currentFolderId, sourceRowIds)) return
+          const canDrop =
+            sourceRowIds.length > 0 && resolveMoveToFolder(currentFolderId, sourceRowIds) !== null
+          setIsBodyDropActive(canDrop)
+          if (!canDrop) return
           e.preventDefault()
           e.dataTransfer.dropEffect = 'move'
-          setIsBodyDropActive(true)
         },
         onDragLeave: (e: DragEvent<HTMLDivElement>) => {
           const relatedTarget = e.relatedTarget
@@ -346,6 +353,7 @@ export function useFolderRowDragDrop({
           e.preventDefault()
           const sourceRowIds =
             readRowDragPayload(e.dataTransfer, DRAG_ROW_MIME) ?? draggedRowIdsRef.current
+          e.stopPropagation()
           const move =
             sourceRowIds.length > 0 ? resolveMoveToFolder(currentFolderId, sourceRowIds) : null
           if (move) dropHandledRef.current = true
 
@@ -94,8 +94,6 @@ export interface SelectableConfig {
 export interface BodyDropConfig {
   /** The drag is over the body and releasing would move something. */
   isActive: boolean
-  /** A drag is in flight that this body could receive — drives the resting affordance. */
-  canDrop: boolean
   onDragOver: (e: DragEvent<HTMLDivElement>) => void
   onDragLeave: (e: DragEvent<HTMLDivElement>) => void
   onDrop: (e: DragEvent<HTMLDivElement>) => void
@@ -396,24 +394,6 @@ const ResourceTable = memo(function ResourceTable({
               ))}
             </div>
           </div>
-          {bodyDrop?.canDrop && rows.length === 0 && (
-            /**
-             * An empty folder has no row to drop on, so the drag would otherwise dead-end here
-             * with no way to tell that releasing still files into this folder. Shown only while
-             * a droppable drag is in flight, so it never intrudes on the resting empty state.
-             */
-            <div
-              className={cn(
-                'm-4 flex flex-col items-center justify-center gap-1 rounded-[10px] border border-dashed py-10 transition-colors',
-                bodyDrop.isActive
-                  ? 'border-[var(--text-subtle)] bg-[var(--surface-4)]'
-                  : 'border-[var(--border)]'
-              )}
-            >
-              <p className='text-[var(--text-body)] text-small'>Drop to move here</p>
-              <p className='text-[var(--text-muted)] text-caption'>This folder is empty</p>
-            </div>
-          )}
           <div
             role='rowgroup'
             className={cn('grid', virtualized && 'relative')}
 
@@ -915,6 +915,9 @@ export function Files() {
         e.stopPropagation()
         e.dataTransfer.dropEffect = isExternalFileDrag ? 'copy' : 'move'
         setActiveDropTargetId(rowId)
+        // The row sits inside the scroll container, whose `dragleave` ignores contained
+        // targets — clear it here so the row and the body never both read as the target.
+        setIsBodyDropActive(false)
         /**
          * Armed for OS file drags too: dropping an upload into a nested folder is the same
          * gesture, and `onDragOver` only fires on folder rows.
@@ -981,39 +984,39 @@ export function Files() {
       onDragEnd: endDrag,
       body: {
         isActive: isBodyDropActive,
-        canDrop: canEdit && draggedRowIds.size > 0,
         onDragOver: (e: DragEvent<HTMLDivElement>) => {
+          /**
+           * Internal row drags only. An OS file drag is already owned by the page-level
+           * handler, which paints the full "Drop to upload" overlay and uploads into this same
+           * folder — claiming it here would double the affordance and, without stopping
+           * propagation, upload every dropped file twice.
+           */
+          if (hasExternalFiles(e.dataTransfer)) return
           const sourceRowIds = draggedRowIdsRef.current
-          const isExternalFileDrag = hasExternalFiles(e.dataTransfer)
-          if (!isExternalFileDrag) {
-            if (sourceRowIds.length === 0) return
-            if (isInvalidFolderTarget(currentFolderId, sourceRowIds)) return
-          }
+          // Recomputed every event: a spring-open changes the destination mid-drag.
+          const canDrop =
+            sourceRowIds.length > 0 && !isInvalidFolderTarget(currentFolderId, sourceRowIds)
+          setIsBodyDropActive(canDrop)
+          if (!canDrop) return
           e.preventDefault()
-          e.dataTransfer.dropEffect = isExternalFileDrag ? 'copy' : 'move'
-          setIsBodyDropActive(true)
+          e.dataTransfer.dropEffect = 'move'
         },
         onDragLeave: (e: DragEvent<HTMLDivElement>) => {
           const relatedTarget = e.relatedTarget
           if (relatedTarget instanceof Node && e.currentTarget.contains(relatedTarget)) return
           setIsBodyDropActive(false)
         },
         onDrop: (e: DragEvent<HTMLDivElement>) => {
+          // Left to the page-level handler, which uploads into this folder already.
+          if (hasExternalFiles(e.dataTransfer)) return
           e.preventDefault()
-          const droppedFiles = Array.from(e.dataTransfer.files ?? [])
+          e.stopPropagation()
           const sourceRowIds =
             readRowDragPayload(e.dataTransfer, FILE_ROW_DRAG_MIME) ?? draggedRowIdsRef.current
           const canMove =
-            droppedFiles.length === 0 &&
-            sourceRowIds.length > 0 &&
-            !isInvalidFolderTarget(currentFolderId, sourceRowIds)
+            sourceRowIds.length > 0 && !isInvalidFolderTarget(currentFolderId, sourceRowIds)
 
           endDrag()
-
-          if (droppedFiles.length > 0) {
-            void uploadFiles(droppedFiles, currentFolderId)
-            return
-          }
           if (!canMove) return
 
           const fileIds: string[] = []