@marimo-team/frontend 0.23.2-dev8 → 0.23.3-dev1

package/src/core/cells/__tests__/logs.test.ts

@@ -5,6 +5,11 @@ import { cellId } from "@/__tests__/branded";
 import type { CellMessage } from "../../kernel/messages";
 import { formatLogTimestamp, getCellLogsForMessage } from "../logs";
 
+// Stable mock reference so every (re)import of use-toast sees the same spy,
+// even after vi.resetModules() clears the module cache between tests.
+const { toastMock } = vi.hoisted(() => ({ toastMock: vi.fn() }));
+vi.mock("@/components/ui/use-toast", () => ({ toast: toastMock }));
+
 describe("getCellLogsForMessage", () => {
   beforeEach(() => {
     // Mock console.log to avoid cluttering test output
@@ -324,6 +329,102 @@ describe("getCellLogsForMessage", () => {
   });
 });
 
+describe("getCellLogsForMessage - internal error toast", () => {
+  // Re-imported per test after vi.resetModules() so the module-level
+  // `didAlreadyToastError` flag starts fresh and all jotai atom references
+  // (initialModeAtom, etc.) match the versions used by the reset logs.ts.
+  let getLogs: typeof import("../logs").getCellLogsForMessage;
+  let store: typeof import("@/core/state/jotai").store;
+  let initialModeAtom: typeof import("@/core/mode").initialModeAtom;
+
+  beforeEach(async () => {
+    vi.spyOn(console, "log").mockImplementation(() => {
+      // no-op
+    });
+    vi.resetModules();
+    ({ getCellLogsForMessage: getLogs } = await import("../logs"));
+    ({ store } = await import("@/core/state/jotai"));
+    ({ initialModeAtom } = await import("@/core/mode"));
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+    vi.clearAllMocks();
+  });
+
+  const makeErrorCellMessage = (id: CellMessage["cell_id"]): CellMessage => ({
+    cell_id: id,
+    console: [],
+    output: {
+      mimetype: "application/vnd.marimo+error",
+      data: [
+        {
+          type: "exception",
+          exception_type: "ValueError",
+          msg: "something exploded",
+          traceback: ["File foo.py, line 1", "ValueError: something exploded"],
+        },
+      ],
+      channel: "marimo-error",
+      timestamp: 0,
+    } as unknown as CellMessage["output"],
+    status: "idle",
+    stale_inputs: null,
+    timestamp: 0,
+  });
+
+  test("shows toast for internal errors in app (read) mode", () => {
+    store.set(initialModeAtom, "read");
+
+    getLogs(makeErrorCellMessage(cellId("cell-err-1")));
+
+    expect(toastMock).toHaveBeenCalledTimes(1);
+    expect(toastMock).toHaveBeenCalledWith(
+      expect.objectContaining({
+        title: "An internal error occurred",
+        variant: "danger",
+      }),
+    );
+  });
+
+  test("does not show toast for internal errors in edit mode", () => {
+    store.set(initialModeAtom, "edit");
+
+    getLogs(makeErrorCellMessage(cellId("cell-err-2")));
+
+    expect(toastMock).not.toHaveBeenCalled();
+  });
+
+  test("edit-mode errors do not consume the once-per-session toast slot", () => {
+    // Errors received while in edit mode should be silently skipped...
+    store.set(initialModeAtom, "edit");
+    getLogs(makeErrorCellMessage(cellId("cell-err-3")));
+    expect(toastMock).not.toHaveBeenCalled();
+
+    // ...and a subsequent error in app mode should still toast.
+    store.set(initialModeAtom, "read");
+    getLogs(makeErrorCellMessage(cellId("cell-err-4")));
+    expect(toastMock).toHaveBeenCalledTimes(1);
+  });
+
+  test("toast only fires once across multiple app-mode errors", () => {
+    store.set(initialModeAtom, "read");
+
+    getLogs(makeErrorCellMessage(cellId("cell-err-5")));
+    getLogs(makeErrorCellMessage(cellId("cell-err-6")));
+
+    expect(toastMock).toHaveBeenCalledTimes(1);
+  });
+
+  test("suppresses toast when initial mode has not been set", () => {
+    // Leave initialModeAtom at its default (undefined); getInitialAppMode
+    // will throw and the logic should swallow it without toasting.
+    getLogs(makeErrorCellMessage(cellId("cell-err-7")));
+
+    expect(toastMock).not.toHaveBeenCalled();
+  });
+});
+
 describe("formatLogTimestamp", () => {
   test("formats unix timestamp correctly", () => {
     // January 1, 2024, 12:00:00 PM UTC

package/src/core/cells/cells.ts

@@ -874,6 +874,24 @@ const {
       cellHandles: nextCellHandles,
     };
   },
+  /**
+   * Rebuild the MultiColumn tree using each cell's `config.column` value.
+   *
+   * Used after a transaction whose `set-config` changes updated cells'
+   * column metadata without physically moving them in the tree. Cells with
+   * `config.column == null` inherit the column of the previous cell in the
+   * given order (see `MultiColumn.fromIdsAndColumns`), which lets the server
+   * send column changes only at column boundaries.
+   */
+  rebuildCellColumns: (state, action: { cellIds: CellId[] }) => {
+    const newCellIds = MultiColumn.fromIdsAndColumns(
+      action.cellIds.map((id) => [
+        id,
+        state.cellData[id]?.config.column ?? null,
+      ]),
+    );
+    return { ...state, cellIds: newCellIds };
+  },
   setCellCodes: (
     state,
     action: {

package/src/core/cells/document-changes.ts

@@ -349,6 +349,7 @@ export function toDocumentChanges(
     case "prepareForRun":
     case "handleCellMessage":
     case "setCellIds":
+    case "rebuildCellColumns":
     case "setCellCodes":
     case "setCells":
     case "setStdinResponse":
@@ -624,7 +625,24 @@ export function applyTransactionChanges(
 ): void {
   const cancelled = cancelledCellIds(changes);
 
-  for (const change of changes) {
+  // Process set-config changes after everything else. The tree must be fully
+  // restructured (create-cell, delete-cell, reorder-cells, move-cell) before
+  // we start applying column metadata, since the follow-up rebuildCellColumns
+  // step interprets each cell's config.column against the *final* flat order.
+  // Sorting is stable within each group.
+  const sortedChanges: TransactionChange[] = [
+    ...changes.filter((c) => c.type !== "set-config"),
+    ...changes.filter((c) => c.type === "set-config"),
+  ];
+
+  // Track whether any change updated a cell's column, and remember the final
+  // flat order produced by a reorder-cells change (if any). After all changes
+  // are applied, these are used to rebuild the MultiColumn tree so that cells
+  // physically move to the column their metadata says they belong in.
+  let hasColumnChange = false;
+  let reorderOrder: CellId[] | null = null;
+
+  for (const change of sortedChanges) {
     if (
       cancelled.size > 0 &&
       "cellId" in change &&
@@ -632,11 +650,26 @@ export function applyTransactionChanges(
     ) {
       continue;
     }
+    if (change.type === "set-config" && change.column != null) {
+      hasColumnChange = true;
+    }
+    if (change.type === "create-cell" && change.config?.column != null) {
+      hasColumnChange = true;
+    }
+    if (change.type === "reorder-cells") {
+      reorderOrder = change.cellIds as CellId[];
+    }
     for (const action of fromDocumentChanges([change], getCurrentCellIds)) {
       // @ts-expect-error - TypeScript is not smart enough to know we have correctly mapped type -> payload
       actions[action.type](action.payload);
     }
   }
+
+  if (hasColumnChange) {
+    actions.rebuildCellColumns({
+      cellIds: reorderOrder ?? getCurrentCellIds(),
+    });
+  }
 }
 
 // ---------------------------------------------------------------------------

package/src/core/cells/logs.ts

@@ -7,6 +7,7 @@ import { Strings } from "@/utils/strings";
 import type { CellMessage, OutputMessage } from "../kernel/messages";
 import { isErrorMime } from "../mime";
 import type { CellId } from "./ids";
+import { initialModeAtom } from "../mode";
 import { store } from "../state/jotai";
 import { tracebackModalAtom } from "../errors/traceback-atom";
 import React from "react";
@@ -83,7 +84,14 @@ export function getCellLogsForMessage(cell: CellMessage): CellLog[] {
         error.type === "internal",
     );
 
-    if (exceptionErrors.length > 0 && !didAlreadyToastError) {
+    // Only show the toast in app mode: edit mode already surfaces errors in
+    // the cell UI, so toasting there would be noisy and duplicative. Read the
+    // atom directly so an unset initial mode (e.g. in tests/islands) simply
+    // returns undefined instead of throwing and masking real errors.
+    const isAppMode = store.get(initialModeAtom) === "read";
+
+    // Only show toast once, and only in app mode
+    if (exceptionErrors.length > 0 && !didAlreadyToastError && isAppMode) {
       didAlreadyToastError = true;
 
       // Find first error with a traceback

package/src/core/codemirror/__tests__/__snapshots__/setup.test.ts.snap

@@ -9,9 +9,7 @@ exports[`snapshot all duplicate keymaps > default keymaps 2`] = `
     },
     {
       "key": "ArrowDown",
-      "preventDefault": true,
       "run": "run",
-      "stopPropagation": true,
     },
     {
       "key": "ArrowDown",
@@ -27,9 +25,7 @@ exports[`snapshot all duplicate keymaps > default keymaps 2`] = `
     },
     {
       "key": "ArrowUp",
-      "preventDefault": true,
       "run": "run",
-      "stopPropagation": true,
     },
     {
       "key": "ArrowUp",
@@ -118,15 +114,12 @@ exports[`snapshot all duplicate keymaps > vim keymaps 2`] = `
     },
     {
       "key": "ArrowDown",
-      "preventDefault": true,
       "run": "run",
-      "stopPropagation": true,
     },
     {
       "key": "ArrowDown",
-      "preventDefault": true,
-      "run": "cursorLineDown",
-      "shift": "selectLineDown",
+      "run": "<no name>",
+      "shift": "<no name>",
     },
   ],
   "ArrowUp": [
@@ -136,15 +129,12 @@ exports[`snapshot all duplicate keymaps > vim keymaps 2`] = `
     },
     {
       "key": "ArrowUp",
-      "preventDefault": true,
       "run": "run",
-      "stopPropagation": true,
     },
     {
       "key": "ArrowUp",
-      "preventDefault": true,
-      "run": "cursorLineUp",
-      "shift": "selectLineUp",
+      "run": "<no name>",
+      "shift": "<no name>",
     },
   ],
   "Backspace": [

package/src/core/codemirror/cells/extensions.ts

@@ -169,8 +169,6 @@ function cellKeymaps({
       },
       {
         key: "ArrowUp",
-        preventDefault: true,
-        stopPropagation: true,
         run: (ev) => {
           // Skip if we are in the middle of an autocompletion
           const hasAutocomplete = completionStatus(ev.state);
@@ -188,8 +186,6 @@ function cellKeymaps({
       },
       {
         key: "ArrowDown",
-        preventDefault: true,
-        stopPropagation: true,
         run: (ev) => {
           // Skip if we are in the middle of an autocompletion
           const hasAutocomplete = completionStatus(ev.state);

package/src/core/codemirror/keymaps/keymaps.ts

@@ -1,8 +1,16 @@
 /* Copyright 2026 Marimo. All rights reserved. */
 
 import {
+  cursorCharLeft,
+  cursorCharRight,
+  cursorLineDown,
+  cursorLineUp,
   insertNewlineAndIndent,
   defaultKeymap as originalDefaultKeymap,
+  selectCharLeft,
+  selectCharRight,
+  selectLineDown,
+  selectLineUp,
   toggleBlockComment,
   toggleComment,
 } from "@codemirror/commands";
@@ -13,7 +21,7 @@ import {
   type KeyBinding,
   keymap,
 } from "@codemirror/view";
-import { getCM, vim } from "@replit/codemirror-vim";
+import { type CodeMirror, getCM, vim } from "@replit/codemirror-vim";
 import type { KeymapConfig } from "@/core/config/config-schema";
 import type { HotkeyProvider } from "@/core/hotkeys/hotkeys";
 import { logNever } from "@/utils/assertNever";
@@ -62,6 +70,12 @@ export function keymapBundle(
             },
           ),
         ),
+        // Arrow keys: use CodeMirror's cursor movement except in vim visual
+        // mode, where vim must handle them to maintain selection.
+        // The original cursorLineUp/Down bindings from the default keymap are
+        // filtered out (see defaultVimKeymap) because their preventDefault
+        // flag blocks vim's handler even when their run function returns false.
+        keymap.of(vimVisualModeArrowKeyBindings()),
         // Base vim mode
         vim({ status: false }),
         // Custom vim keymaps for cell navigation
@@ -101,12 +115,22 @@ const overrideKeymap = (keymap: HotkeyProvider): readonly KeyBinding[] => {
 };
 
 const defaultVimKeymap = once(() => {
-  const toRemove = new Set(["Enter", "Ctrl-v"]);
+  const toRemove = new Set([
+    "Enter",
+    "Ctrl-v",
+    "ArrowUp",
+    "ArrowDown",
+    "ArrowLeft",
+    "ArrowRight",
+  ]);
   // Remove conflicting keys from the keymap
   // Enter (<CR>) adds a new line
   //   - it should just go to the next line
   // Ctrl-v goes to the bottom of the cell
   //   - should enter blockwise visual mode
+  // ArrowUp/ArrowDown (cursorLineUp/Down) always handle the event and have
+  //   preventDefault, which blocks vim's handler from processing arrow keys.
+  //   Replaced with visual-mode-aware wrappers in keymapBundle.
   return defaultKeymap().filter(
     (k) => !toRemove.has(k.key || k.mac || k.linux || k.win || ""),
   );
@@ -155,6 +179,49 @@ function doubleCharacterListener(
   ]);
 }
 
+function isInVimVisualMode(cm: CodeMirror | undefined | null): boolean {
+  return cm?.state.vim?.visualMode === true;
+}
+
+/**
+ * In vim visual mode, arrow keys must be handled by vim to maintain selection.
+ * Wrap each arrow key's run and shift so they defer to vim in visual mode,
+ * but use CodeMirror's cursor commands in all other modes.
+ */
+function vimVisualModeArrowKeyBindings(): KeyBinding[] {
+  const wrap =
+    (cmd: Command): Command =>
+    (view) => {
+      if (isInVimVisualMode(getCM(view))) {
+        return false;
+      }
+      return cmd(view);
+    };
+
+  return [
+    {
+      key: "ArrowDown",
+      run: wrap(cursorLineDown),
+      shift: wrap(selectLineDown),
+    },
+    {
+      key: "ArrowUp",
+      run: wrap(cursorLineUp),
+      shift: wrap(selectLineUp),
+    },
+    {
+      key: "ArrowLeft",
+      run: wrap(cursorCharLeft),
+      shift: wrap(selectCharLeft),
+    },
+    {
+      key: "ArrowRight",
+      run: wrap(cursorCharRight),
+      shift: wrap(selectCharRight),
+    },
+  ];
+}
+
 export const visibleForTesting = {
   defaultKeymap,
   defaultVimKeymap,

package/src/core/constants.ts

@@ -7,6 +7,7 @@ export const Constants = {
   discordLink: "https://marimo.io/discord?ref=notebook",
   docsPage: "https://docs.marimo.io",
   youtube: "https://www.youtube.com/@marimo-team",
+  molab: "https://molab.marimo.io",
 };
 
 export const KnownQueryParams = {

package/src/core/islands/bridge.ts

@@ -237,6 +237,7 @@ export class IslandsPyodideBridge implements RunRequests, EditRequests {
   sendPdb = throwNotImplemented;
   sendCreateFileOrFolder = throwNotImplemented;
   sendDeleteFileOrFolder = throwNotImplemented;
+  sendCopyFileOrFolder = throwNotImplemented;
   sendRenameFileOrFolder = throwNotImplemented;
   sendUpdateFile = throwNotImplemented;
   sendFileDetails = throwNotImplemented;

package/src/core/mode.ts

@@ -1,6 +1,6 @@
 /* Copyright 2026 Marimo. All rights reserved. */
 
-import { atom } from "jotai";
+import { atom, useAtomValue } from "jotai";
 import { isIslands } from "@/core/islands/utils";
 import { assertExists } from "@/utils/assertExists";
 import { invariant } from "@/utils/invariant";
@@ -79,3 +79,12 @@ export const viewStateAtom = atom<ViewState>({
 export const initialModeAtom = atom<AppMode | undefined>(undefined);
 
 export const kioskModeAtom = atom<boolean>(false);
+
+/**
+ * Whether installing packages is allowed in the current view. False in read
+ * mode, since end-users of a deployed notebook cannot mutate its environment.
+ */
+export function useInstallAllowed(): boolean {
+  const { mode } = useAtomValue(viewStateAtom);
+  return mode !== "read";
+}

package/src/core/network/requests-lazy.ts

@@ -90,6 +90,7 @@ const ACTIONS: Record<keyof AllRequests, Action> = {
   sendSearchFiles: "startConnection",
   sendCreateFileOrFolder: "throwError",
   sendDeleteFileOrFolder: "throwError",
+  sendCopyFileOrFolder: "throwError",
   sendRenameFileOrFolder: "throwError",
   sendUpdateFile: "throwError",
   sendFileDetails: "throwError",

package/src/core/network/requests-network.ts

@@ -312,6 +312,14 @@ export function createNetworkRequests(): EditRequests & RunRequests {
         })
         .then(handleResponse);
     },
+    sendCopyFileOrFolder: async (request) => {
+      await waitForConnectionOpen();
+      return getClient()
+        .POST("/api/files/copy", {
+          body: request,
+        })
+        .then(handleResponse);
+    },
     sendRenameFileOrFolder: async (request) => {
       await waitForConnectionOpen();
       return getClient()

package/src/core/network/requests-static.ts

@@ -66,6 +66,7 @@ export function createStaticRequests(): EditRequests & RunRequests {
     sendPdb: throwNotInEditMode,
     sendCreateFileOrFolder: throwNotInEditMode,
     sendDeleteFileOrFolder: throwNotInEditMode,
+    sendCopyFileOrFolder: throwNotInEditMode,
     sendRenameFileOrFolder: throwNotInEditMode,
     sendUpdateFile: throwNotInEditMode,
     sendFileDetails: throwNotInEditMode,

package/src/core/network/requests-toasting.tsx

@@ -51,6 +51,7 @@ export function createErrorToastingRequests(
     sendPdb: "Failed to start debug session",
     sendCreateFileOrFolder: "Failed to create file or folder",
     sendDeleteFileOrFolder: "Failed to delete file or folder",
+    sendCopyFileOrFolder: "Failed to duplicate file or folder",
     sendRenameFileOrFolder: "Failed to rename file or folder",
     sendUpdateFile: "Failed to update file",
     sendFileDetails: "Failed to get file details",

package/src/core/network/types.ts

@@ -23,6 +23,8 @@ export type ExportAsIPYNBRequest = schemas["ExportAsIPYNBRequest"];
 export type ExportAsScriptRequest = schemas["ExportAsScriptRequest"];
 export type ExportAsPDFRequest = schemas["ExportAsPDFRequest"];
 export type UpdateCellOutputsRequest = schemas["UpdateCellOutputsRequest"];
+export type FileCopyRequest = schemas["FileCopyRequest"];
+export type FileCopyResponse = schemas["FileCopyResponse"];
 export type FileCreateRequest = schemas["FileCreateRequest"];
 export type FileCreateResponse = schemas["FileCreateResponse"];
 export type FileDeleteRequest = schemas["FileDeleteRequest"];
@@ -168,6 +170,7 @@ export interface EditRequests {
   sendDeleteFileOrFolder: (
     request: FileDeleteRequest,
   ) => Promise<FileDeleteResponse>;
+  sendCopyFileOrFolder: (request: FileCopyRequest) => Promise<FileCopyResponse>;
   sendRenameFileOrFolder: (
     request: FileMoveRequest,
   ) => Promise<FileMoveResponse>;

package/src/core/wasm/__tests__/bridge.test.ts

@@ -0,0 +1,113 @@
+/* Copyright 2026 Marimo. All rights reserved. */
+
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+const { mockNotebookReadFile, rpcListeners } = vi.hoisted(() => ({
+  mockNotebookReadFile: vi.fn(),
+  rpcListeners: {} as Record<string, () => void>,
+}));
+
+// Mock browser globals before any imports
+vi.stubGlobal("crossOriginIsolated", false);
+vi.stubGlobal(
+  "Worker",
+  vi.fn(() => ({
+    addEventListener: vi.fn(),
+    postMessage: vi.fn(),
+    terminate: vi.fn(),
+  })),
+);
+
+class MockURL extends URL {
+  static override createObjectURL = vi.fn(() => "blob:mock-url");
+  static override revokeObjectURL = vi.fn();
+}
+vi.stubGlobal("URL", MockURL);
+
+vi.mock("@/core/wasm/rpc", () => ({
+  getWorkerRPC: () => ({
+    proxy: {
+      request: {
+        bridge: vi.fn(),
+        startSession: vi.fn(),
+        readFile: vi.fn(),
+        readNotebook: vi.fn(),
+        saveNotebook: vi.fn(),
+      },
+      send: { consumerReady: vi.fn() },
+    },
+    addMessageListener: (event: string, cb: () => void) => {
+      rpcListeners[event] = cb;
+    },
+  }),
+}));
+
+vi.mock("@/core/meta/globals", () => ({
+  getMarimoVersion: () => "0.0.0-test",
+}));
+
+vi.mock("@/core/wasm/utils", () => ({
+  isWasm: () => true,
+}));
+
+vi.mock("@/core/wasm/store", () => ({
+  fallbackFileStore: { readFile: vi.fn(), saveFile: vi.fn() },
+  notebookFileStore: { readFile: mockNotebookReadFile, saveFile: vi.fn() },
+}));
+
+// Import after all mocks are set up
+import { store } from "@/core/state/jotai";
+import { initialModeAtom } from "@/core/mode";
+import { PyodideBridge } from "../bridge";
+
+// Access INSTANCE once at module level so the constructor runs (and
+// addMessageListener populates rpcListeners) before any test executes.
+void PyodideBridge.INSTANCE;
+
+describe("PyodideBridge.readCode", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  afterEach(() => {
+    store.set(initialModeAtom, undefined);
+  });
+
+  it("reads from notebookFileStore in read mode", async () => {
+    store.set(initialModeAtom, "read");
+    // Trigger getSaveWorker — it reads the current mode and returns a stub
+    // whose readNotebook delegates to notebookFileStore.
+    rpcListeners.initialized();
+    mockNotebookReadFile.mockResolvedValue(
+      "import numpy as np\nprint(np.__version__)",
+    );
+
+    const result = await PyodideBridge.INSTANCE.readCode();
+
+    expect(result).toEqual({
+      contents: "import numpy as np\nprint(np.__version__)",
+    });
+    expect(mockNotebookReadFile).toHaveBeenCalledTimes(1);
+  });
+
+  it("returns empty string when notebookFileStore has no code in read mode", async () => {
+    store.set(initialModeAtom, "read");
+    rpcListeners.initialized();
+    mockNotebookReadFile.mockResolvedValue(null);
+
+    const result = await PyodideBridge.INSTANCE.readCode();
+
+    expect(result).toEqual({ contents: "" });
+  });
+
+  it("does not call notebookFileStore in edit mode", async () => {
+    store.set(initialModeAtom, "edit");
+    // getSaveWorker in edit mode creates a real worker (mocked); readNotebook
+    // goes to the RPC proxy, not notebookFileStore.
+    rpcListeners.initialized();
+
+    await PyodideBridge.INSTANCE.readCode();
+
+    expect(mockNotebookReadFile).not.toHaveBeenCalled();
+  });
+});

package/src/core/wasm/bridge.ts

@@ -17,6 +17,7 @@ import type {
   EditRequests,
   ExportAsHTMLRequest,
   ExportAsMarkdownRequest,
+  FileCopyResponse,
   FileCreateResponse,
   FileDeleteResponse,
   FileDetailsResponse,
@@ -66,10 +67,10 @@ export class PyodideBridge implements RunRequests, EditRequests {
 
   private getSaveWorker(): SaveWorker {
     if (getInitialAppMode() === "read") {
-      Logger.debug("Skipping SaveWorker in read-mode");
+      Logger.debug("Using partially disabled SaveWorker in read-mode");
       return {
         readFile: throwNotImplemented,
-        readNotebook: throwNotImplemented,
+        readNotebook: async () => (await notebookFileStore.readFile()) ?? "",
         saveNotebook: throwNotImplemented,
       };
     }
@@ -443,6 +444,16 @@ export class PyodideBridge implements RunRequests, EditRequests {
     return response as FileDeleteResponse;
   };
 
+  sendCopyFileOrFolder: EditRequests["sendCopyFileOrFolder"] = async (
+    request,
+  ) => {
+    const response = await this.rpc.proxy.request.bridge({
+      functionName: "copy_file_or_directory",
+      payload: request,
+    });
+    return response as FileCopyResponse;
+  };
+
   sendRenameFileOrFolder: EditRequests["sendRenameFileOrFolder"] = async (
     request,
   ) => {

package/src/core/wasm/worker/types.ts

@@ -11,6 +11,8 @@ import type {
   CopyNotebookRequest,
   ExportAsHTMLRequest,
   ExportAsMarkdownRequest,
+  FileCopyRequest,
+  FileCopyResponse,
   FileCreateRequest,
   FileCreateResponse,
   FileDeleteRequest,
@@ -86,6 +88,7 @@ export interface RawBridge {
   delete_file_or_directory(
     request: FileDeleteRequest,
   ): Promise<FileDeleteResponse>;
+  copy_file_or_directory(request: FileCopyRequest): Promise<FileCopyResponse>;
   move_file_or_directory(request: FileMoveRequest): Promise<FileMoveResponse>;
   update_file(request: FileUpdateRequest): Promise<FileUpdateResponse>;
   load_packages(request: string): Promise<string>;