@marimo-team/frontend 0.24.1-dev84 → 0.24.1-dev85

package/src/components/editor/file-tree/__tests__/requesting-tree.test.ts

@@ -3,8 +3,9 @@ import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";
 import { MockModules } from "@/__mocks__/common";
 import { toast } from "@/components/ui/use-toast";
 import type { FilePath } from "@/utils/paths";
-import { RequestingTree } from "../requesting-tree";
+import { fileTreeNodeId, RequestingTree } from "../requesting-tree";
 
+const getRoots = vi.fn();
 const sendListFiles = vi.fn();
 const sendCreateFileOrFolder = vi.fn();
 const sendDeleteFileOrFolder = vi.fn();
@@ -13,499 +14,475 @@ const sendRenameFileOrFolder = vi.fn();
 
 vi.mock("@/components/ui/use-toast", () => MockModules.toast());
 
+const PRIMARY_FILES = [
+  {
+    id: "/root/file1",
+    name: "file1",
+    path: "/root/file1",
+    isDirectory: false,
+    isMarimoFile: false,
+    children: [],
+  },
+  {
+    id: "/root/folder1",
+    name: "folder1",
+    path: "/root/folder1",
+    isDirectory: true,
+    isMarimoFile: false,
+    children: [],
+  },
+];
+
+const PRIMARY_ROOT_ID = fileTreeNodeId("/root", "/root");
+const PRIMARY_FILE_ID = fileTreeNodeId("/root", "/root/file1");
+const EXTERNAL_ROOT_ID = fileTreeNodeId("/external", "/external");
+
 describe("RequestingTree", () => {
-  let requestingTree: RequestingTree;
-  const mockOnChange = vi.fn();
+  let tree: RequestingTree;
+  const onChange = vi.fn();
 
   beforeEach(async () => {
-    requestingTree = new RequestingTree({
+    getRoots.mockResolvedValue({
+      roots: [
+        { path: "/root", name: "workspace", isPrimary: true },
+        { path: "/external", name: "Shared", isPrimary: false },
+      ],
+    });
+    sendListFiles.mockImplementation(async ({ path }: { path: string }) => ({
+      files: path === "/root" ? PRIMARY_FILES : [],
+      root: path,
+    }));
+    sendCreateFileOrFolder.mockResolvedValue({ success: true });
+    sendDeleteFileOrFolder.mockResolvedValue({ success: true });
+    sendCopyFileOrFolder.mockResolvedValue({ success: true });
+    sendRenameFileOrFolder.mockResolvedValue({ success: true });
+
+    tree = new RequestingTree({
+      getRoots,
       listFiles: sendListFiles,
       createFileOrFolder: sendCreateFileOrFolder,
       deleteFileOrFolder: sendDeleteFileOrFolder,
       copyFileOrFolder: sendCopyFileOrFolder,
       renameFileOrFolder: sendRenameFileOrFolder,
     });
-    sendListFiles.mockResolvedValue({
-      files: [
-        { id: "1.1", name: "file1", path: "/root/file1" },
-        {
-          id: "1.2",
-          name: "folder1",
-          isDirectory: true,
-          path: "/root/folder1",
-        },
-        {
-          id: "1.3",
-          name: "folder2",
-          isDirectory: true,
-          path: "/root/folder2",
-        },
-      ],
-      root: "/root",
-    });
-    await requestingTree.initialize(mockOnChange);
+    await tree.initialize(onChange);
   });
 
   afterEach(() => {
     vi.clearAllMocks();
   });
 
-  test("initialize should load files and set rootPath", async () => {
-    expect(sendListFiles).toHaveBeenCalledWith({ path: "" });
-    expect(requestingTree.getRootPath()).toBe("/root");
-    expect(mockOnChange).toHaveBeenCalledWith([
-      { id: "1.1", name: "file1", path: "/root/file1" },
-      { id: "1.2", name: "folder1", isDirectory: true, path: "/root/folder1" },
-      { id: "1.3", name: "folder2", isDirectory: true, path: "/root/folder2" },
+  test("initializes with visible, unloaded root nodes", () => {
+    expect(getRoots).toHaveBeenCalledOnce();
+    expect(sendListFiles).not.toHaveBeenCalled();
+    expect(tree.getPrimaryRootPath()).toBe("/root");
+    expect(onChange).toHaveBeenLastCalledWith([
+      expect.objectContaining({
+        id: PRIMARY_ROOT_ID,
+        name: "workspace",
+        isRoot: true,
+        isPrimaryRoot: true,
+        children: [],
+      }),
+      expect.objectContaining({
+        id: EXTERNAL_ROOT_ID,
+        name: "Shared",
+        isRoot: true,
+        isPrimaryRoot: false,
+        children: [],
+      }),
     ]);
   });
 
-  test("expand should load children for a directory", async () => {
-    sendListFiles.mockResolvedValue({
-      files: [{ id: "2", name: "file2", path: "/roo/folder1/file2" }],
+  test("flattens the primary root when there are no additional roots", async () => {
+    getRoots.mockResolvedValueOnce({
+      roots: [{ path: "/root", name: "workspace", isPrimary: true }],
+    });
+    const singleRootOnChange = vi.fn();
+    const singleRootTree = new RequestingTree({
+      getRoots,
+      listFiles: sendListFiles,
+      createFileOrFolder: sendCreateFileOrFolder,
+      deleteFileOrFolder: sendDeleteFileOrFolder,
+      copyFileOrFolder: sendCopyFileOrFolder,
+      renameFileOrFolder: sendRenameFileOrFolder,
     });
-    const result = await requestingTree.expand("1.2");
-    expect(result).toBe(true);
-    expect(sendListFiles).toHaveBeenCalledWith({ path: "/root/folder1" });
-    expect(mockOnChange).toHaveBeenCalled();
-    const lastCall = mockOnChange.mock.calls.at(-1);
-    expect(lastCall).toBeDefined();
-    expect(lastCall![0]).toMatchInlineSnapshot(`
-      [
-        {
-          "id": "1.1",
-          "name": "file1",
-          "path": "/root/file1",
-        },
-        {
-          "children": [
-            {
-              "id": "2",
-              "name": "file2",
-              "path": "/roo/folder1/file2",
-            },
-          ],
-          "id": "1.2",
-          "isDirectory": true,
-          "name": "folder1",
-          "path": "/root/folder1",
-        },
-        {
-          "id": "1.3",
-          "isDirectory": true,
-          "name": "folder2",
-          "path": "/root/folder2",
-        },
-      ]
-    `);
-  });
 
-  test("rename should change the name and path of a file", async () => {
-    sendRenameFileOrFolder.mockResolvedValue({ success: true });
+    await singleRootTree.initialize(singleRootOnChange);
 
-    await requestingTree.rename("1.1", "file2");
-    expect(sendRenameFileOrFolder).toHaveBeenCalledWith({
-      path: "/root/file1",
-      newPath: "/root/file2",
+    expect(sendListFiles).toHaveBeenCalledWith({ path: "/root" });
+    expect(singleRootOnChange).toHaveBeenLastCalledWith([
+      expect.objectContaining({
+        id: PRIMARY_FILE_ID,
+        path: "/root/file1",
+        isRoot: false,
+        isPrimaryRoot: true,
+      }),
+      expect.objectContaining({
+        id: fileTreeNodeId("/root", "/root/folder1"),
+        path: "/root/folder1",
+        isRoot: false,
+        isPrimaryRoot: true,
+      }),
+    ]);
+
+    await singleRootTree.createFile({ name: "new.txt", parentId: null });
+    expect(sendCreateFileOrFolder).toHaveBeenCalledWith({
+      path: "/root",
+      type: "file",
+      name: "new.txt",
     });
-    expect(mockOnChange).toHaveBeenCalled();
-    const lastCall = mockOnChange.mock.calls.at(-1);
-    expect(lastCall).toBeDefined();
-    expect(lastCall![0]).toMatchInlineSnapshot(`
-      [
-        {
-          "id": "1.1",
-          "name": "file1",
-          "path": "/root/file1",
-        },
-        {
-          "id": "1.2",
-          "isDirectory": true,
-          "name": "folder1",
-          "path": "/root/folder1",
-        },
-        {
-          "id": "1.3",
-          "isDirectory": true,
-          "name": "folder2",
-          "path": "/root/folder2",
-        },
-      ]
-    `);
   });
 
-  test("move should change the parent of a file", async () => {
-    sendRenameFileOrFolder.mockResolvedValue({ success: true });
-
-    await requestingTree.move(["1.1"], "1.2");
-    expect(sendRenameFileOrFolder).toHaveBeenCalled();
-    expect(mockOnChange).toHaveBeenCalled();
-    const lastCall = mockOnChange.mock.calls.at(-1);
-    expect(lastCall).toBeDefined();
-    expect(lastCall![0]).toMatchInlineSnapshot(`
-      [
-        {
-          "id": "1.1",
-          "name": "file1",
-          "path": "/root/file1",
-        },
-        {
-          "children": [
-            {
-              "id": "1.1",
-              "name": "file1",
-              "path": "/root/folder1/file1",
-            },
-          ],
-          "id": "1.2",
-          "isDirectory": true,
-          "name": "folder1",
-          "path": "/root/folder1",
-        },
+  test("expands each root lazily and annotates its descendants", async () => {
+    sendListFiles.mockResolvedValueOnce({
+      files: [
         {
-          "id": "1.3",
-          "isDirectory": true,
-          "name": "folder2",
-          "path": "/root/folder2",
+          id: "/external/data.csv",
+          path: "/external/data.csv",
+          name: "data.csv",
+          isDirectory: false,
+          isMarimoFile: false,
+          children: [],
         },
-      ]
-    `);
-  });
-
-  test("copy should duplicate a file", async () => {
-    sendCopyFileOrFolder.mockResolvedValue({ success: true });
-
-    await requestingTree.copy("1.1", "file1_copy");
-    expect(sendCopyFileOrFolder).toHaveBeenCalledWith({
-      path: "/root/file1",
-      newPath: "/root/file1_copy",
+      ],
+      root: "/external",
     });
-    expect(mockOnChange).toHaveBeenCalled();
-  });
-
-  test("delete should drop a file on success", async () => {
-    sendDeleteFileOrFolder.mockResolvedValue({ success: true });
 
-    await requestingTree.delete("1.1");
-    expect(sendDeleteFileOrFolder).toHaveBeenCalledWith({
-      path: "/root/file1",
-    });
-    const lastCall = mockOnChange.mock.calls.at(-1);
-    expect(lastCall?.[0].map((f: { id: string }) => f.id)).toEqual([
-      "1.2",
-      "1.3",
-    ]);
+    expect(await tree.expand(EXTERNAL_ROOT_ID)).toBe(true);
+    expect(sendListFiles).toHaveBeenCalledWith({ path: "/external" });
+    expect(onChange.mock.calls.at(-1)?.[0][1].children[0]).toEqual(
+      expect.objectContaining({
+        path: "/external/data.csv",
+        rootPath: "/external",
+        isPrimaryRoot: false,
+        isRoot: false,
+      }),
+    );
   });
 
-  test("createFile should create a new file", async () => {
-    sendCreateFileOrFolder.mockResolvedValue({ success: true });
-
-    await requestingTree.createFile({ name: "file3", parentId: "1.2" });
+  test("uses the primary root for toolbar creation without a selection", async () => {
+    await tree.createFile({ name: "new.txt", parentId: null });
     expect(sendCreateFileOrFolder).toHaveBeenCalledWith({
-      path: "/root/folder1",
+      path: "/root",
       type: "file",
-      name: "file3",
+      name: "new.txt",
     });
-    expect(mockOnChange).toHaveBeenCalled();
   });
 
-  test("createFile should create a new notebook", async () => {
-    sendCreateFileOrFolder.mockResolvedValue({ success: true });
-
-    await requestingTree.createFile({
-      name: "notebook1",
-      parentId: "1.2",
-      type: "notebook",
-    });
+  test("creates and uploads into an explicitly selected root", async () => {
+    await tree.createFolder("exports", EXTERNAL_ROOT_ID);
     expect(sendCreateFileOrFolder).toHaveBeenCalledWith({
-      path: "/root/folder1",
-      type: "notebook",
-      name: "notebook1",
+      path: "/external",
+      type: "directory",
+      name: "exports",
     });
-    expect(mockOnChange).toHaveBeenCalled();
   });
 
-  test("createFolder should create a new folder", async () => {
-    sendCreateFileOrFolder.mockResolvedValue({ success: true });
-
-    await requestingTree.createFolder("folder3", "1.2");
-    expect(sendCreateFileOrFolder).toHaveBeenCalled();
-    expect(mockOnChange).toHaveBeenCalled();
+  test("prevents mutations of structural root nodes", async () => {
+    await tree.rename(EXTERNAL_ROOT_ID, "renamed");
+    await tree.copy(EXTERNAL_ROOT_ID, "copy");
+    await tree.delete(EXTERNAL_ROOT_ID);
+
+    expect(sendRenameFileOrFolder).not.toHaveBeenCalled();
+    expect(sendCopyFileOrFolder).not.toHaveBeenCalled();
+    expect(sendDeleteFileOrFolder).not.toHaveBeenCalled();
+    expect(toast).toHaveBeenCalledWith(
+      expect.objectContaining({
+        description: "File browser roots cannot be modified",
+      }),
+    );
   });
 
-  test("refreshAll should refresh data for all open folders", async () => {
-    await requestingTree.refreshAll(["1.1"]);
-    expect(sendListFiles).toHaveBeenCalled();
-    expect(mockOnChange).toHaveBeenCalled();
-    const lastCall = mockOnChange.mock.calls.at(-1);
-    expect(lastCall).toBeDefined();
-    expect(lastCall![0]).toMatchInlineSnapshot(`
-      [
-        {
-          "id": "1.1",
-          "name": "file1",
-          "path": "/root/file1",
-        },
-        {
-          "id": "1.2",
-          "isDirectory": true,
-          "name": "folder1",
-          "path": "/root/folder1",
-        },
-        {
-          "id": "1.3",
-          "isDirectory": true,
-          "name": "folder2",
-          "path": "/root/folder2",
-        },
-      ]
-    `);
-  });
+  test("supports copying, renaming, and deleting files by absolute path", async () => {
+    await tree.expand(PRIMARY_ROOT_ID);
 
-  test("refreshPath should refresh an uploaded file's destination", async () => {
-    sendListFiles.mockImplementation(async ({ path }: { path: string }) => {
-      if (path === "/root/folder1") {
-        return {
-          files: [
-            {
-              id: "uploaded",
-              name: "uploaded.csv",
-              path: "/root/folder1/uploaded.csv",
-            },
-          ],
-        };
-      }
-      return {
-        files: [
-          { id: "1.1", name: "file1", path: "/root/file1" },
-          {
-            id: "1.2",
-            name: "folder1",
-            isDirectory: true,
-            path: "/root/folder1",
-          },
-          {
-            id: "1.3",
-            name: "folder2",
-            isDirectory: true,
-            path: "/root/folder2",
-          },
-        ],
-      };
+    await tree.copy(PRIMARY_FILE_ID, "file1_copy");
+    expect(sendCopyFileOrFolder).toHaveBeenCalledWith({
+      path: "/root/file1",
+      newPath: "/root/file1_copy",
     });
 
-    await requestingTree.refreshPath("/root/folder1" as FilePath);
+    await tree.rename(PRIMARY_FILE_ID, "file2");
+    expect(sendRenameFileOrFolder).toHaveBeenCalledWith({
+      path: "/root/file1",
+      newPath: "/root/file2",
+    });
 
-    expect(sendListFiles).toHaveBeenCalledWith({ path: "/root/folder1" });
-    expect(mockOnChange.mock.calls.at(-1)?.[0]).toEqual([
-      { id: "1.1", name: "file1", path: "/root/file1" },
-      {
-        id: "1.2",
-        name: "folder1",
-        isDirectory: true,
-        path: "/root/folder1",
-        children: [
-          {
-            id: "uploaded",
-            name: "uploaded.csv",
-            path: "/root/folder1/uploaded.csv",
-          },
-        ],
-      },
-      {
-        id: "1.3",
-        name: "folder2",
-        isDirectory: true,
-        path: "/root/folder2",
-      },
-    ]);
+    await tree.delete(PRIMARY_FILE_ID);
+    expect(sendDeleteFileOrFolder).toHaveBeenCalledWith({
+      path: "/root/file1",
+    });
   });
 
-  describe("when API fails", () => {
-    test("initialize should handle errors gracefully", async () => {
-      requestingTree = new RequestingTree({
-        listFiles: sendListFiles,
-        createFileOrFolder: sendCreateFileOrFolder,
-        deleteFileOrFolder: sendDeleteFileOrFolder,
-        copyFileOrFolder: sendCopyFileOrFolder,
-        renameFileOrFolder: sendRenameFileOrFolder,
-      });
-      sendListFiles.mockRejectedValue(new Error("Network error"));
-      await requestingTree.initialize(mockOnChange);
-      expect(toast).toHaveBeenCalledWith({
-        title: "Failed",
-        description: expect.any(String),
-      });
+  describe("failed mutations", () => {
+    beforeEach(async () => {
+      await tree.expand(PRIMARY_ROOT_ID);
+      sendListFiles.mockClear();
+      onChange.mockClear();
     });
 
-    test("rename should handle API failure", async () => {
-      sendRenameFileOrFolder.mockResolvedValue({
+    test("does not update or refresh after a failed copy", async () => {
+      sendCopyFileOrFolder.mockResolvedValueOnce({
         success: false,
-        message: "Error renaming",
+        message: "Permission denied",
       });
 
-      await requestingTree.rename("1.1", "file2");
-      expect(sendRenameFileOrFolder).toHaveBeenCalledWith({
-        path: "/root/file1",
-        newPath: "/root/file2",
-      });
+      await tree.copy(PRIMARY_FILE_ID, "file1_copy");
+
+      expect(sendListFiles).not.toHaveBeenCalled();
+      expect(onChange).not.toHaveBeenCalled();
       expect(toast).toHaveBeenCalledWith({
         title: "Failed",
-        description: "Error renaming",
+        description: "Permission denied",
       });
     });
 
-    test("rename should NOT mutate the local tree on API failure", async () => {
-      sendRenameFileOrFolder.mockResolvedValue({
+    test("does not update or refresh after a failed rename", async () => {
+      sendRenameFileOrFolder.mockResolvedValueOnce({
         success: false,
-        message: "Error renaming",
+        message: "Permission denied",
       });
-      const changesBefore = mockOnChange.mock.calls.length;
-
-      await requestingTree.rename("1.1", "file2");
 
-      // No further onChange calls should fire after the failed rename, so the
-      // tree stays in sync with the backend.
-      expect(mockOnChange.mock.calls.length).toBe(changesBefore);
-    });
+      await tree.rename(PRIMARY_FILE_ID, "file2");
 
-    test("delete should NOT drop the node on API failure", async () => {
-      sendDeleteFileOrFolder.mockResolvedValue({
-        success: false,
-        message: "Error deleting",
-      });
-      const changesBefore = mockOnChange.mock.calls.length;
-
-      await requestingTree.delete("1.1");
-      expect(sendDeleteFileOrFolder).toHaveBeenCalledWith({
-        path: "/root/file1",
-      });
+      expect(sendListFiles).not.toHaveBeenCalled();
+      expect(onChange).not.toHaveBeenCalled();
       expect(toast).toHaveBeenCalledWith({
         title: "Failed",
-        description: "Error deleting",
+        description: "Permission denied",
       });
-      expect(mockOnChange.mock.calls.length).toBe(changesBefore);
     });
 
-    test("move should NOT mutate the local tree when rename fails", async () => {
-      sendRenameFileOrFolder.mockResolvedValue({
+    test("does not update or refresh after a failed delete", async () => {
+      sendDeleteFileOrFolder.mockResolvedValueOnce({
         success: false,
-        message: "Error moving",
+        message: "Permission denied",
       });
 
-      await requestingTree.move(["1.1"], "1.2");
+      await tree.delete(PRIMARY_FILE_ID);
 
+      expect(sendListFiles).not.toHaveBeenCalled();
+      expect(onChange).not.toHaveBeenCalled();
       expect(toast).toHaveBeenCalledWith({
         title: "Failed",
-        description: "Error moving",
+        description: "Permission denied",
       });
-      // The last emitted state should still have file1 at the top level, not
-      // moved under folder1.
-      const lastCall = mockOnChange.mock.calls.at(-1);
-      expect(lastCall?.[0]).toEqual([
-        { id: "1.1", name: "file1", path: "/root/file1" },
-        {
-          id: "1.2",
-          name: "folder1",
-          isDirectory: true,
-          path: "/root/folder1",
-        },
-        {
-          id: "1.3",
-          name: "folder2",
-          isDirectory: true,
-          path: "/root/folder2",
-        },
-      ]);
     });
 
-    test("copy should handle API failure", async () => {
-      sendCopyFileOrFolder.mockResolvedValue({
+    test("does not update or refresh after a failed move", async () => {
+      sendRenameFileOrFolder.mockResolvedValueOnce({
         success: false,
-        message: "Error duplicating",
+        message: "Permission denied",
       });
 
-      await requestingTree.copy("1.1", "file1_copy");
-      expect(sendCopyFileOrFolder).toHaveBeenCalledWith({
-        path: "/root/file1",
-        newPath: "/root/file1_copy",
-      });
+      await tree.move([PRIMARY_FILE_ID], EXTERNAL_ROOT_ID);
+
+      expect(sendListFiles).not.toHaveBeenCalled();
+      expect(onChange).not.toHaveBeenCalled();
       expect(toast).toHaveBeenCalledWith({
         title: "Failed",
-        description: "Error duplicating",
+        description: "Permission denied",
       });
     });
+  });
+
+  test("moves files across roots and refreshes both parents", async () => {
+    await tree.expand(PRIMARY_ROOT_ID);
+    sendListFiles.mockClear();
+
+    await tree.move([PRIMARY_FILE_ID], EXTERNAL_ROOT_ID);
 
-    test("move should handle missing parent node gracefully", async () => {
-      await requestingTree.move(["1.x"], "2");
-      expect(sendRenameFileOrFolder).not.toHaveBeenCalled();
-      expect(mockOnChange).toHaveBeenCalledTimes(3);
+    expect(sendRenameFileOrFolder).toHaveBeenCalledWith({
+      path: "/root/file1",
+      newPath: "/external/file1",
     });
+    expect(sendListFiles).toHaveBeenCalledWith({ path: "/root" });
+    expect(sendListFiles).toHaveBeenCalledWith({ path: "/external" });
+  });
+
+  test("refreshes configured roots when every node is collapsed", async () => {
+    await tree.refreshAll([]);
+    expect(sendListFiles).toHaveBeenCalledWith({ path: "/root" });
+    expect(sendListFiles).toHaveBeenCalledWith({ path: "/external" });
+  });
+
+  test("refreshes supplied open folders in addition to configured roots", async () => {
+    await tree.expand(PRIMARY_ROOT_ID);
+    sendListFiles.mockClear();
+
+    await tree.refreshAll([fileTreeNodeId("/root", "/root/folder1")]);
+
+    expect(sendListFiles).toHaveBeenCalledWith({ path: "/root" });
+    expect(sendListFiles).toHaveBeenCalledWith({ path: "/external" });
+    expect(sendListFiles).toHaveBeenCalledWith({ path: "/root/folder1" });
+  });
+
+  test("keeps existing children when a refresh fails", async () => {
+    await tree.expand(PRIMARY_ROOT_ID);
+    const beforeRefresh = onChange.mock.calls.at(-1)?.[0];
+    sendListFiles.mockRejectedValueOnce(new Error("Network error"));
+
+    await tree.refreshPath("/root" as FilePath);
+
+    expect(onChange.mock.calls.at(-1)?.[0]).toEqual(beforeRefresh);
+  });
 
-    test("refreshAll should handle API errors without crashing", async () => {
-      sendListFiles.mockRejectedValue(new Error("Network error"));
-      await requestingTree.refreshAll(["1.2"]);
-      expect(sendListFiles).toHaveBeenCalled();
-      // Ensure onChange is still called to update UI even if data might not have changed
-      expect(mockOnChange).toHaveBeenCalled();
+  test("namespaces duplicate paths under overlapping roots", async () => {
+    getRoots.mockResolvedValueOnce({
+      roots: [
+        { path: "/repo", name: "repo", isPrimary: true },
+        { path: "/repo/data", name: "Data", isPrimary: false },
+      ],
     });
+    sendListFiles.mockImplementation(async ({ path }: { path: string }) => ({
+      root: path,
+      files:
+        path === "/repo"
+          ? [
+              {
+                id: "/repo/data",
+                name: "data",
+                path: "/repo/data",
+                isDirectory: true,
+                isMarimoFile: false,
+                children: [],
+              },
+            ]
+          : [
+              {
+                id: "/repo/data/file.csv",
+                name: "file.csv",
+                path: "/repo/data/file.csv",
+                isDirectory: false,
+                isMarimoFile: false,
+                children: [],
+              },
+            ],
+    }));
+    const overlapOnChange = vi.fn();
+    const overlapTree = new RequestingTree({
+      getRoots,
+      listFiles: sendListFiles,
+      createFileOrFolder: sendCreateFileOrFolder,
+      deleteFileOrFolder: sendDeleteFileOrFolder,
+      copyFileOrFolder: sendCopyFileOrFolder,
+      renameFileOrFolder: sendRenameFileOrFolder,
+    });
+    await overlapTree.initialize(overlapOnChange);
+
+    const primaryRootId = fileTreeNodeId("/repo", "/repo");
+    const nestedDirectoryId = fileTreeNodeId("/repo", "/repo/data");
+    const additionalRootId = fileTreeNodeId("/repo/data", "/repo/data");
+    expect(nestedDirectoryId).not.toBe(additionalRootId);
+
+    await overlapTree.expand(primaryRootId);
+    await overlapTree.expand(nestedDirectoryId);
+    await overlapTree.expand(additionalRootId);
+
+    const roots = overlapOnChange.mock.calls.at(-1)?.[0];
+    expect(roots[0].children[0].id).toBe(nestedDirectoryId);
+    expect(roots[1].id).toBe(additionalRootId);
+    expect(roots[0].children[0].children[0].id).toBe(
+      fileTreeNodeId("/repo", "/repo/data/file.csv"),
+    );
+    expect(roots[1].children[0].id).toBe(
+      fileTreeNodeId("/repo/data", "/repo/data/file.csv"),
+    );
   });
 
-  describe("relativeFromRoot", () => {
-    test("should return relative path for Unix paths", async () => {
-      const tree = new RequestingTree({
+  describe("primary-root paths", () => {
+    test("returns relative paths only inside the primary root", () => {
+      expect(tree.getPrimaryRelativePath("/root/src/file.py" as FilePath)).toBe(
+        "src/file.py",
+      );
+      expect(
+        tree.getPrimaryRelativePath("/rooted/file.py" as FilePath),
+      ).toBeNull();
+      expect(
+        tree.getPrimaryRelativePath("/external/file.py" as FilePath),
+      ).toBeNull();
+    });
+
+    test("supports Windows path boundaries case-insensitively", async () => {
+      getRoots.mockResolvedValueOnce({
+        roots: [
+          {
+            path: "C:\\Users\\Test\\Project",
+            name: "Project",
+            isPrimary: true,
+          },
+        ],
+      });
+      const windowsTree = new RequestingTree({
+        getRoots,
         listFiles: sendListFiles,
         createFileOrFolder: sendCreateFileOrFolder,
         deleteFileOrFolder: sendDeleteFileOrFolder,
         copyFileOrFolder: sendCopyFileOrFolder,
         renameFileOrFolder: sendRenameFileOrFolder,
       });
-
-      sendListFiles.mockResolvedValue({
-        files: [],
-        root: "/home/user/project",
-      });
-
-      await tree.initialize(vi.fn());
-
-      const relativePath = tree.relativeFromRoot(
-        "/home/user/project/src/file.py" as FilePath,
-      );
-      expect(relativePath).toBe("src/file.py");
+      await windowsTree.initialize(vi.fn());
+
+      expect(
+        windowsTree.getPrimaryRelativePath(
+          "c:\\users\\test\\project\\src\\file.py" as FilePath,
+        ),
+      ).toBe("src\\file.py");
+      expect(
+        windowsTree.getPrimaryRelativePath(
+          "C:\\Users\\Test\\Project-old\\file.py" as FilePath,
+        ),
+      ).toBeNull();
     });
 
-    test("should return relative path for Windows paths", async () => {
-      const tree = new RequestingTree({
+    test("treats backslashes in POSIX paths as filename characters", async () => {
+      const rootPath = "/root/data\\archive";
+      const filePath = `${rootPath}/file.txt`;
+      getRoots.mockResolvedValueOnce({
+        roots: [{ path: rootPath, name: "archive", isPrimary: true }],
+      });
+      sendListFiles.mockResolvedValueOnce({
+        root: rootPath,
+        files: [
+          {
+            id: filePath,
+            path: filePath,
+            name: "file.txt",
+            isDirectory: false,
+            isMarimoFile: false,
+            children: [],
+          },
+        ],
+      });
+      const posixTree = new RequestingTree({
+        getRoots,
         listFiles: sendListFiles,
         createFileOrFolder: sendCreateFileOrFolder,
         deleteFileOrFolder: sendDeleteFileOrFolder,
         copyFileOrFolder: sendCopyFileOrFolder,
         renameFileOrFolder: sendRenameFileOrFolder,
       });
+      await posixTree.initialize(vi.fn());
 
-      sendListFiles.mockResolvedValue({
-        files: [],
-        root: "C:\\Users\\test\\project",
-      });
-
-      await tree.initialize(vi.fn());
-
-      const relativePath = tree.relativeFromRoot(
-        "C:\\Users\\test\\project\\src\\file.py" as FilePath,
+      expect(posixTree.getPrimaryRelativePath(filePath as FilePath)).toBe(
+        "file.txt",
       );
-      expect(relativePath).toBe("src\\file.py");
+      await posixTree.copy(fileTreeNodeId(rootPath, filePath), "copy.txt");
+      expect(sendCopyFileOrFolder).toHaveBeenCalledWith({
+        path: filePath,
+        newPath: `${rootPath}/copy.txt`,
+      });
     });
 
-    test("should return original path when not under root", async () => {
-      const relativePath = requestingTree.relativeFromRoot(
-        "/other/path/file.py" as FilePath,
+    test("uses configured names in root-qualified display paths", () => {
+      expect(tree.getDisplayPath("/root/data.csv" as FilePath)).toBe(
+        "data.csv",
       );
-      expect(relativePath).toBe("/other/path/file.py");
-    });
-
-    test("should handle root path exactly", async () => {
-      const relativePath = requestingTree.relativeFromRoot("/root" as FilePath);
-      expect(relativePath).toBe("/root");
+      expect(tree.getDisplayPath("/external/data.csv" as FilePath)).toBe(
+        "Shared/data.csv",
+      );
+      expect(tree.getDisplayPath("/external" as FilePath)).toBe("Shared");
     });
   });
 });