@@ -2,32 +2,68 @@
 
 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.
  *
- * `dragend` fires on the SOURCE ROW, which is not guaranteed to still exist: spring-loading
- * navigates into another folder mid-drag, which unmounts it. A row-level handler would then
- * never run, leaving the drag ghost stuck on the page, every row frozen at drag opacity, and a
- * stale source id that makes the next drop resolve against rows the user never picked up.
+ * 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
+ *    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.
  *
- * Listening on `window` catches the event wherever it lands — including a drag cancelled with
- * Escape or released outside the window, which never reaches a row at all.
+ * 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.
  *
  * `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 any cleanup wired into it would then
+ * callback would re-run this effect on every render, and the teardown wired into it would then
  * abort drags that are still in progress — a bug this exact hook already shipped once.
  */
 export function useDragTeardown(teardown: () => void): void {
   const teardownRef = useRef<() => void>(teardown)
   teardownRef.current = teardown
 
   useEffect(() => {
-    const handleDragEnd = () => teardownRef.current()
-    window.addEventListener('dragend', handleDragEnd)
-    window.addEventListener('drop', handleDragEnd)
+    let idleTimer: ReturnType<typeof setTimeout> | null = null
+
+    const clearIdleTimer = () => {
+      if (idleTimer !== null) clearTimeout(idleTimer)
+      idleTimer = null
+    }
+
+    const runTeardown = () => {
+      clearIdleTimer()
+      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)
     return () => {
-      window.removeEventListener('dragend', handleDragEnd)
-      window.removeEventListener('drop', handleDragEnd)
+      clearIdleTimer()
+      window.removeEventListener('dragend', runTeardown)
+      window.removeEventListener('drop', runTeardown)
+      window.removeEventListener('dragover', handleDragOver)
     }
   }, [])
 }
@@ -66,7 +66,7 @@ export interface UseFolderRowDragDropOptions {
    * dropping first. Forward `options` to the folder-navigation setter so one drag leaves one
    * back-stack entry. Omit to disable spring-loading. See {@link useSpringLoadedFolder}.
    */
-  onSpringOpenFolder?: (folderId: string, options: SpringOpenOptions) => void
+  onSpringOpenFolder?: (folderId: string | null, options: SpringOpenOptions) => void
   /**
    * The folder the list is currently showing (`null` at the workspace root). Enables dropping
    * onto the list body to file into it — the only way to land a drag that spring-opened into an
@@ -123,12 +123,49 @@ export function useFolderRowDragDrop({
     selection,
   }
 
-  const springLoad = useSpringLoadedFolder({ onSpringOpen: onSpringOpenFolder ?? noop })
+  /**
+   * Where the drag started, and whether it ever navigated. A drag that spring-opens its way into
+   * a folder and is then cancelled — or dropped somewhere else entirely — would otherwise strand
+   * the user several levels deep in a folder they never chose to open, with the list showing
+   * somewhere they did not ask to be. The workflow sidebar collapses its own spring-opened
+   * folders for exactly this reason.
+   */
+  const dragOriginFolderIdRef = useRef<string | null>(null)
+  const didSpringOpenRef = useRef(false)
+  /** Set by whichever drop handler ran, so a completed drop keeps the destination on screen. */
+  const dropHandledRef = useRef(false)
+
+  const currentFolderIdRef = useRef(currentFolderId)
+  currentFolderIdRef.current = currentFolderId
+
+  const springLoad = useSpringLoadedFolder({
+    onSpringOpen: (folderId, options) => {
+      didSpringOpenRef.current = true
+      ;(onSpringOpenFolder ?? noop)(folderId, options)
+    },
+  })
+
+  const onSpringOpenFolderRef = useRef(onSpringOpenFolder)
+  onSpringOpenFolderRef.current = onSpringOpenFolder
 
   const dragGhost = useRowDragGhost()
 
   /** Returns the list to its resting state once a drag is over, however it ended. */
   const endDrag = useCallback(() => {
+    /**
+     * Navigate back to where the drag started when it spring-opened folders but never landed.
+     * `replace`, not `push`: the spring-opens are being undone, so they should leave no trace in
+     * the back stack rather than a trail the user has to walk out of.
+     */
+    if (
+      didSpringOpenRef.current &&
+      !dropHandledRef.current &&
+      dragOriginFolderIdRef.current !== currentFolderIdRef.current
+    ) {
+      onSpringOpenFolderRef.current?.(dragOriginFolderIdRef.current, { history: 'replace' })
+    }
+    didSpringOpenRef.current = false
+    dropHandledRef.current = false
     dragGhost.remove()
     draggedRowIdsRef.current = []
     springLoad.reset()
@@ -198,6 +235,7 @@ export function useFolderRowDragDrop({
           return
         }
 
+        dragOriginFolderIdRef.current = currentFolderIdRef.current
         const { selection } = optionsRef.current
         /**
          * Read the selection in display order rather than insertion order, so a shift-range
@@ -271,6 +309,7 @@ export function useFolderRowDragDrop({
           target.kind === 'folder' && sourceRowIds.length > 0
             ? resolveMove(rowId, sourceRowIds)
             : null
+        if (move) dropHandledRef.current = true
 
         /**
          * Ends the drag here rather than leaving it to `dragend`. This handler stops
@@ -309,6 +348,7 @@ export function useFolderRowDragDrop({
             readRowDragPayload(e.dataTransfer, DRAG_ROW_MIME) ?? draggedRowIdsRef.current
           const move =
             sourceRowIds.length > 0 ? resolveMoveToFolder(currentFolderId, sourceRowIds) : null
+          if (move) dropHandledRef.current = true
           endDrag()
           if (move) optionsRef.current.onMoveRows(move, currentFolderId)
         },
 
@@ -60,6 +60,12 @@ export interface ResourceActionBarProps {
   onDelete?: () => void
   /** Disables every action while a bulk mutation is in flight. */
   isLoading?: boolean
+  /**
+   * Largest selection the bulk endpoints accept. Past it the server rejects the whole request,
+   * so the bar says so and disables the actions rather than letting the user confirm something
+   * that cannot succeed.
+   */
+  maxSelectable?: number
   className?: string
 }
 
@@ -83,10 +89,14 @@ export function ResourceActionBar({
   moveOptions,
   onDelete,
   isLoading = false,
+  maxSelectable,
   className,
 }: ResourceActionBarProps) {
   if (selectedCount === 0) return null
 
+  const exceedsLimit = maxSelectable !== undefined && selectedCount > maxSelectable
+  const actionsDisabled = isLoading || exceedsLimit
+
   return (
     <div
       className={cn(
@@ -96,24 +106,35 @@ export function ResourceActionBar({
       )}
     >
       <div className='flex items-center gap-2 rounded-[10px] border border-[var(--border)] bg-[var(--surface-2)] px-2 py-1.5'>
-        <span className='px-1 text-[var(--text-secondary)] text-small'>
-          {selectedCount} selected
+        <span
+          className={cn(
+            'px-1 text-small',
+            exceedsLimit ? 'text-[var(--text-error)]' : 'text-[var(--text-secondary)]'
+          )}
+        >
+          {exceedsLimit
+            ? `${selectedCount} selected · select ${maxSelectable} or fewer`
+            : `${selectedCount} selected`}
         </span>
         <div className='flex items-center gap-[5px]'>
           {onDownload && (
             <ActionButton
               icon={Download}
               label='Download'
               onClick={onDownload}
-              disabled={isLoading}
+              disabled={actionsDisabled}
             />
           )}
           {onMove && moveOptions && (
             <DropdownMenu>
               <Tooltip.Root>
                 <Tooltip.Trigger asChild>
                   <DropdownMenuTrigger asChild>
-                    <Button variant='ghost' disabled={isLoading} className={ACTION_BUTTON_CLASS}>
+                    <Button
+                      variant='ghost'
+                      disabled={actionsDisabled}
+                      className={ACTION_BUTTON_CLASS}
+                    >
                       <Folder className='size-[12px]' />
                     </Button>
                   </DropdownMenuTrigger>
@@ -137,7 +158,12 @@ export function ResourceActionBar({
             </DropdownMenu>
           )}
           {onDelete && (
-            <ActionButton icon={Trash} label='Delete' onClick={onDelete} disabled={isLoading} />
+            <ActionButton
+              icon={Trash}
+              label='Delete'
+              onClick={onDelete}
+              disabled={actionsDisabled}
+            />
           )}
         </div>
       </div>
 
@@ -102,7 +102,17 @@ export function useResourceRowSelection({
   const prevVisibleRowIdsRef = useRef(visibleRowIds)
   useEffect(() => {
     if (prevVisibleRowIdsRef.current === visibleRowIds) return
+    /**
+     * Identity is only a cheap first test — it changes for reasons that are not list changes.
+     * Both foldered pages rebuild every row on each inline-rename keystroke (the edit value
+     * lives in the row memo), so a rename would otherwise clear the shift anchor mid-edit and
+     * the next shift-click would start a fresh range instead of extending the user's.
+     */
+    const unchanged =
+      prevVisibleRowIdsRef.current.length === visibleRowIds.length &&
+      prevVisibleRowIdsRef.current.every((rowId, index) => rowId === visibleRowIds[index])
     prevVisibleRowIdsRef.current = visibleRowIds
+    if (unchanged) return
     anchorIndexRef.current = NO_ANCHOR
     const visible = new Set(visibleRowIds)
     setSelectedRowIds((prev) => {
 
@@ -368,6 +368,7 @@ export function Files() {
   const [isDirty, setIsDirty] = useState(false)
   const [saveStatus, setSaveStatus] = useState<SaveStatus>('idle')
   const [activeDropTargetId, setActiveDropTargetId] = useState<string | null>(null)
+  const [isBodyDropActive, setIsBodyDropActive] = useState(false)
   const [draggedRowIds, setDraggedRowIds] = useState<Set<string>>(() => EMPTY_DRAGGED_ROW_IDS)
   const [previewMode, setPreviewMode] = useState<PreviewMode>(() => {
     if (isNewFile) return 'editor'
@@ -717,6 +718,42 @@ export function Files() {
 
   const descendantFolderIdsByFolderId = useMemo(() => buildDescendantIndex(folders), [folders])
 
+  /**
+   * Whether dropping `sourceRowIds` into `targetFolderId` would move anything.
+   *
+   * Takes a folder id rather than a row id because the destination is not always a row: the
+   * list body files into the folder currently open, which has no row of its own, and a drag
+   * that spring-opened into an empty folder has nothing else to land on.
+   */
+  const isInvalidFolderTarget = useCallback(
+    (targetFolderId: string | null, sourceRowIds: string[]) => {
+      for (const sourceRowId of sourceRowIds) {
+        const source = parseRowId(sourceRowId)
+        if (source.kind !== 'folder') continue
+        if (source.id === targetFolderId) return true
+        if (
+          targetFolderId !== null &&
+          descendantFolderIdsByFolderId.get(source.id)?.has(targetFolderId)
+        )
+          return true
+      }
+
+      const allAlreadyInTarget = sourceRowIds.every((sourceRowId) => {
+        const source = parseRowId(sourceRowId)
+        if (source.kind === 'file') {
+          return (
+            (filesRef.current.find((f) => f.id === source.id)?.folderId ?? null) === targetFolderId
+          )
+        }
+        return (
+          (foldersRef.current.find((f) => f.id === source.id)?.parentId ?? null) === targetFolderId
+        )
+      })
+      return allAlreadyInTarget
+    },
+    [descendantFolderIdsByFolderId]
+  )
+
   const isInvalidDropTarget = useCallback(
     (targetRowId: string, sourceRowIds: string[]) => {
       const target = parseRowId(targetRowId)
@@ -831,6 +868,7 @@ export function Files() {
     setDraggedRowIds(EMPTY_DRAGGED_ROW_IDS)
     setIsDraggingOver(false)
     setActiveDropTargetId(null)
+    setIsBodyDropActive(false)
   }, [dragGhost, springLoad])
 
   useDragTeardown(endDrag)
@@ -941,6 +979,56 @@ export function Files() {
           })
       },
       onDragEnd: endDrag,
+      body: {
+        isActive: isBodyDropActive,
+        canDrop: canEdit && draggedRowIds.size > 0,
+        onDragOver: (e: DragEvent<HTMLDivElement>) => {
+          const sourceRowIds = draggedRowIdsRef.current
+          const isExternalFileDrag = hasExternalFiles(e.dataTransfer)
+          if (!isExternalFileDrag) {
+            if (sourceRowIds.length === 0) return
+            if (isInvalidFolderTarget(currentFolderId, sourceRowIds)) return
+          }
+          e.preventDefault()
+          e.dataTransfer.dropEffect = isExternalFileDrag ? 'copy' : 'move'
+          setIsBodyDropActive(true)
+        },
+        onDragLeave: (e: DragEvent<HTMLDivElement>) => {
+          const relatedTarget = e.relatedTarget
+          if (relatedTarget instanceof Node && e.currentTarget.contains(relatedTarget)) return
+          setIsBodyDropActive(false)
+        },
+        onDrop: (e: DragEvent<HTMLDivElement>) => {
+          e.preventDefault()
+          const droppedFiles = Array.from(e.dataTransfer.files ?? [])
+          const sourceRowIds =
+            readRowDragPayload(e.dataTransfer, FILE_ROW_DRAG_MIME) ?? draggedRowIdsRef.current
+          const canMove =
+            droppedFiles.length === 0 &&
+            sourceRowIds.length > 0 &&
+            !isInvalidFolderTarget(currentFolderId, sourceRowIds)
+
+          endDrag()
+
+          if (droppedFiles.length > 0) {
+            void uploadFiles(droppedFiles, currentFolderId)
+            return
+          }
+          if (!canMove) return
+
+          const fileIds: string[] = []
+          const folderIds: string[] = []
+          for (const sourceRowId of sourceRowIds) {
+            const source = parseRowId(sourceRowId)
+            if (source.kind === 'file') fileIds.push(source.id)
+            else folderIds.push(source.id)
+          }
+          void moveItems
+            .mutateAsync({ workspaceId, fileIds, folderIds, targetFolderId: currentFolderId })
+            .then(() => clearSelection())
+            .catch((error) => logger.error('Failed to move items into the open folder:', error))
+        },
+      },
     }),
     [
       activeDropTargetId,
@@ -950,6 +1038,10 @@ export function Files() {
       selectedRowIds,
       visibleRowIds,
       isInvalidDropTarget,
+      isInvalidFolderTarget,
+      isBodyDropActive,
+      currentFolderId,
+      clearSelection,
       uploadFiles,
       workspaceId,
     ]