fix(files): keep the view in a spring-opened folder when an OS upload lands there

Author: waleedlatif1

apps/sim/app/workspace/[workspaceId]/files/files.tsx

@@ -1147,6 +1147,12 @@ export function Files() {
   const handleDrop = async (e: React.DragEvent) => {
     if (!hasExternalFiles(e.dataTransfer)) return
     e.preventDefault()
+    /**
+     * The upload lands in the folder currently open, so the view must stay there. Without this
+     * the window-level teardown treats the drag as unconsumed and returns to the folder it
+     * began in — pulling the user out of the folder they just spring-opened to receive it.
+     */
+    springNav.markDropHandled()
     dragCounterRef.current = 0
     setIsDraggingOver(false)
     const dropped = Array.from(e.dataTransfer.files)

apps/sim/lib/knowledge/application/bulk.ts

@@ -200,6 +200,13 @@ export const bulkMoveKnowledgeItems = defineAuthorizedKnowledgeUseCase({
      * selected folders plus their descendants, so this rejects both "into itself" and "into its
      * own child" before anything is written. Without it the resources move, the folders then fail
      * their cycle check, and the caller is left with a half-applied selection.
+     *
+     * This is a fast-fail optimization, not the enforcement point. It reads a snapshot taken
+     * outside the folder mutation lock, so a concurrent reparent can invalidate it between the
+     * check and the write. The invariant itself is enforced where it must be — `updateFolder`
+     * re-checks `wouldCreateFolderCycle` inside `acquireFolderMutationLock`, so a cycle is never
+     * created. Losing that race costs a reported per-folder `failed` alongside resources that
+     * did move, which is the batch's documented `sequential_best_effort` outcome, not corruption.
      */
     if (input.targetFolderId !== null && plan.covered.has(input.targetFolderId)) {
       throw new OrchestrationError(

apps/sim/lib/table/application/bulk.ts

@@ -227,6 +227,13 @@ export const bulkMoveTables = defineAuthorizedTableUseCase({
      * selected folders plus their descendants, so this rejects both "into itself" and "into its
      * own child" before anything is written. Without it the tables move, the folders then fail
      * their cycle check, and the caller is left with a half-applied selection.
+     *
+     * This is a fast-fail optimization, not the enforcement point. It reads a snapshot taken
+     * outside the folder mutation lock, so a concurrent reparent can invalidate it between the
+     * check and the write. The invariant itself is enforced where it must be — `updateFolder`
+     * re-checks `wouldCreateFolderCycle` inside `acquireFolderMutationLock`, so a cycle is never
+     * created. Losing that race costs a reported per-folder `failed` alongside resources that
+     * did move, which is the batch's documented `sequential_best_effort` outcome, not corruption.
      */
     if (input.targetFolderId !== null && plan.covered.has(input.targetFolderId)) {
       throw new OrchestrationError(